forgecad 0.10.5 → 0.11.0

package/dist-cli/forgecad.js

@@ -141,7 +141,7 @@ import {
   updateConstraintValue,
   validateSimulationModel,
   wrapOCCTShapeBackend
-} from "./chunk-VNM67DIV.js";
+} from "./chunk-MNDROM7T.js";
 
 // cli/forgecad.ts
 import { Command, Flags, Help, flush as flushOclif, handle as handleOclif, run as runOclif } from "@oclif/core";
@@ -2896,9 +2896,9 @@ function captureSnapshot(sketch) {
   };
 }
 function loadSnapshots() {
-  const path5 = join2(SNAPSHOT_DIR, "constraint-snapshots.json");
-  if (!existsSync(path5)) return {};
-  return JSON.parse(readFileSync2(path5, "utf-8"));
+  const path7 = join2(SNAPSHOT_DIR, "constraint-snapshots.json");
+  if (!existsSync(path7)) return {};
+  return JSON.parse(readFileSync2(path7, "utf-8"));
 }
 function saveSnapshots(data) {
   if (!existsSync(SNAPSHOT_DIR)) mkdirSync(SNAPSHOT_DIR, { recursive: true });
@@ -4076,9 +4076,9 @@ function exactRoute(note) {
 function facetedRoute(blocker, note) {
   return { kind: "faceted", blocker, note };
 }
-function partExample(family, path5, route, note, primaryShapes) {
+function partExample(family, path7, route, note, primaryShapes) {
   return {
-    path: path5,
+    path: path7,
     family,
     class: "part",
     validation: "part-runtime",
@@ -4087,9 +4087,9 @@ function partExample(family, path5, route, note, primaryShapes) {
     note
   };
 }
-function assemblyExample(path5, note, expect4) {
+function assemblyExample(path7, note, expect4) {
   return {
-    path: path5,
+    path: path7,
     family: "non-part",
     class: "assembly",
     validation: "assembly-runtime",
@@ -4097,9 +4097,9 @@ function assemblyExample(path5, note, expect4) {
     expect: expect4
   };
 }
-function runtimeSceneExample(path5, note, expect4) {
+function runtimeSceneExample(path7, note, expect4) {
   return {
-    path: path5,
+    path: path7,
     family: "non-part",
     class: "runtime-scene",
     validation: "runtime-scene",
@@ -4107,9 +4107,9 @@ function runtimeSceneExample(path5, note, expect4) {
     expect: expect4
   };
 }
-function sketchExample(path5, note, expect4) {
+function sketchExample(path7, note, expect4) {
   return {
-    path: path5,
+    path: path7,
     family: "non-part",
     class: "sketch",
     validation: "sketch-svg",
@@ -4117,9 +4117,9 @@ function sketchExample(path5, note, expect4) {
     expect: expect4
   };
 }
-function experimentalExample(path5, blocker, taskRef, note) {
+function experimentalExample(path7, blocker, taskRef, note) {
   return {
-    path: path5,
+    path: path7,
     family: "experimental",
     class: "experimental",
     validation: "experimental-runtime",
@@ -4139,6 +4139,8 @@ var API_EXACT_PART_PATHS = [
   "examples/api/folded-service-panel-cover.forge.js",
   "examples/api/group-vs-union.forge.js",
   "examples/api/patterns.forge.js",
+  "examples/api/param-spline2d-g-continuity.forge.js",
+  "examples/api/param-path2d.forge.js",
   "examples/api/text2d-basics.forge.js",
   "examples/api/text2d-font.forge.js",
   "examples/api/extrude-options.forge.js",
@@ -4157,6 +4159,11 @@ var API_FACETED_PARTS = [
     path: "examples/api/profile-2020-b-slot6.forge.js",
     blocker: "The direct 3D profile helper still lowers through segmented profile geometry, so the extrusion must stay on the faceted route for now.",
     note: "The sketch half of the example remains exact-capable; the 3D helper is the intentional blocker."
+  },
+  {
+    path: "examples/api/surface-variable-thickness-panel.forge.js",
+    blocker: "Variable-thickness surface shells lower through sampled UV normal offsets because exact B-rep variable offsets are not available yet.",
+    note: "The example validates the new Thickness.grid() API and the sampled watertight shell path."
   }
 ];
 var API_RECOVERED_FACETED_PARTS = [
@@ -4173,7 +4180,7 @@ var COMPILER_CORPUS_PATHS = [
 ];
 var API_AND_CORPUS_EXAMPLE_MANIFEST = [
   ...API_EXACT_PART_PATHS.map(
-    (path5) => partExample("api-parts", path5, exactRoute("This API example now stays inside the defended exact-route subset."))
+    (path7) => partExample("api-parts", path7, exactRoute("This API example now stays inside the defended exact-route subset."))
   ),
   ...API_FACETED_PARTS.map(
     (entry) => partExample("api-parts", entry.path, facetedRoute(entry.blocker, entry.note), void 0, entry.primaryShapes)
@@ -4182,7 +4189,7 @@ var API_AND_CORPUS_EXAMPLE_MANIFEST = [
     (entry) => partExample("api-parts", entry.path, facetedRoute(entry.blocker, entry.note), void 0, entry.primaryShapes)
   ),
   ...COMPILER_CORPUS_PATHS.map(
-    (path5) => partExample("compiler-corpus", path5, exactRoute("The compiler corpus is the defended ordinary-part exact subset and must stay exact."))
+    (path7) => partExample("compiler-corpus", path7, exactRoute("The compiler corpus is the defended ordinary-part exact subset and must stay exact."))
   )
 ];
 
@@ -4936,8 +4943,8 @@ var VALIDATION_PATH_BY_CLASS = {
   sketch: "sketch-svg",
   experimental: "experimental-runtime"
 };
-function normalizeManifestPath(path5) {
-  return path5.replaceAll("\\", "/");
+function normalizeManifestPath(path7) {
+  return path7.replaceAll("\\", "/");
 }
 function parseArgs(argv) {
   let profile = "smoke";
@@ -4977,25 +4984,25 @@ function parseArgs(argv) {
 }
 function assertManifestCoverage(entries) {
   const manifestPaths = entries.map((entry) => entry.path);
-  const duplicates = manifestPaths.filter((path5, index) => manifestPaths.indexOf(path5) !== index);
+  const duplicates = manifestPaths.filter((path7, index) => manifestPaths.indexOf(path7) !== index);
   const duplicatePaths = [...new Set(duplicates)].sort();
   const discovered = listExampleArtifacts();
   const _manifestSet = new Set(manifestPaths);
   const discoveredSet = new Set(discovered);
   const unclassified = [];
-  const missingFiles = manifestPaths.filter((path5) => !discoveredSet.has(path5));
+  const missingFiles = manifestPaths.filter((path7) => !discoveredSet.has(path7));
   const issues = [];
   if (duplicatePaths.length > 0) {
     issues.push(`Duplicate manifest entries:
-${duplicatePaths.map((path5) => `  - ${path5}`).join("\n")}`);
+${duplicatePaths.map((path7) => `  - ${path7}`).join("\n")}`);
   }
   if (unclassified.length > 0) {
     issues.push(`Unclassified example artifacts:
-${unclassified.map((path5) => `  - ${path5}`).join("\n")}`);
+${unclassified.map((path7) => `  - ${path7}`).join("\n")}`);
   }
   if (missingFiles.length > 0) {
     issues.push(`Manifest entries that point at missing files:
-${missingFiles.map((path5) => `  - ${path5}`).join("\n")}`);
+${missingFiles.map((path7) => `  - ${path7}`).join("\n")}`);
   }
   if (issues.length > 0) {
     throw new Error(`Example manifest coverage failed.
@@ -5031,7 +5038,7 @@ function selectEntries(entries, args) {
   }
   if (args.examples.length > 0) {
     const exampleSet = new Set(args.examples);
-    const missingExamples = args.examples.filter((path5) => !entries.some((entry) => entry.path === path5));
+    const missingExamples = args.examples.filter((path7) => !entries.some((entry) => entry.path === path7));
     if (missingExamples.length > 0) {
       throw new Error(`Unknown manifest example path(s): ${missingExamples.join(", ")}`);
     }
@@ -5500,9 +5507,9 @@ import { basename as basename3 } from "path";
 var RENDERABLE_INPUT_EXTENSIONS = [".forge.js", ".js", ".stl", ".obj", ".3mf", ".step", ".stp"];
 var EXACT_EXPORT_INPUT_EXTENSIONS = [".forge.js", ".js", ".step", ".stp"];
 var SCRIPT_INPUT_EXTENSIONS = [".forge.js", ".js"];
-function requireInputPaths(inputPaths, usage27) {
+function requireInputPaths(inputPaths, usage28) {
   if (inputPaths.length === 0) {
-    throw new Error(usage27);
+    throw new Error(usage28);
   }
   return inputPaths;
 }
@@ -5554,16 +5561,16 @@ function hasSupportedExtension(inputPath, extensions) {
 import { existsSync as existsSync3, readFileSync as readFileSync4, statSync as statSync3 } from "fs";
 import { homedir } from "os";
 import { resolve as resolve5 } from "path";
-function expandUserPath(path5) {
-  if (path5 === "~") return homedir();
-  if (path5.startsWith("~/")) return resolve5(homedir(), path5.slice(2));
-  return resolve5(path5);
+function expandUserPath(path7) {
+  if (path7 === "~") return homedir();
+  if (path7.startsWith("~/")) return resolve5(homedir(), path7.slice(2));
+  return resolve5(path7);
 }
 function looksLikePath(value) {
   return value.endsWith(".json") || value.includes("/") || value.includes("\\") || value.startsWith(".") || value.startsWith("~");
 }
-function readJsonFile(path5, flag) {
-  const resolved = expandUserPath(path5);
+function readJsonFile(path7, flag) {
+  const resolved = expandUserPath(path7);
   if (!existsSync3(resolved)) {
     throw new Error(`${flag} file not found: ${resolved}`);
   }
@@ -5576,8 +5583,8 @@ function readJsonFile(path5, flag) {
   }
   return content;
 }
-function readCliJsonFile(path5, flag) {
-  return readJsonFile(path5, flag);
+function readCliJsonFile(path7, flag) {
+  return readJsonFile(path7, flag);
 }
 function readCliJsonOrFile(value, flag) {
   const trimmed = value.trim();
@@ -5702,21 +5709,21 @@ function extractImports(code) {
   let m;
   const forgeRe = new RegExp(FORGE_IMPORT_RE.source, FORGE_IMPORT_RE.flags);
   while ((m = forgeRe.exec(code)) !== null) {
-    const path5 = m[1] ?? m[2];
+    const path7 = m[1] ?? m[2];
     const fn = m[0].match(
       /\b(importMesh|importStep|importSvgSketch|Import\.mesh|Import\.step|Import\.image|Import\.svgSketch|Import\.dxfSketch|compareWith)/
     )?.[1];
-    add3(path5, kindMap[fn] ?? "forgeMesh");
+    add3(path7, kindMap[fn] ?? "forgeMesh");
   }
   const reqRe = new RegExp(REQUIRE_RE.source, REQUIRE_RE.flags);
   while ((m = reqRe.exec(code)) !== null) {
-    const path5 = m[1] ?? m[2];
-    add3(path5, "require");
+    const path7 = m[1] ?? m[2];
+    add3(path7, "require");
   }
   const esRe = new RegExp(ES_IMPORT_RE.source, ES_IMPORT_RE.flags);
   while ((m = esRe.exec(code)) !== null) {
-    const path5 = m[1] ?? m[2];
-    add3(path5, "esImport");
+    const path7 = m[1] ?? m[2];
+    add3(path7, "esImport");
   }
   return refs;
 }
@@ -5742,8 +5749,8 @@ function resolveRelative(fromFile, importPath) {
   }
   return resolved.join("/");
 }
-function isCompareBinaryPath(path5) {
-  return /\.(?:stl|obj|3mf|step|stp)$/i.test(path5);
+function isCompareBinaryPath(path7) {
+  return /\.(?:stl|obj|3mf|step|stp)$/i.test(path7);
 }
 function collectDependencies(entryFile, allFiles) {
   const codeFiles = {};
@@ -5801,18 +5808,18 @@ function collectDependencies(entryFile, allFiles) {
 var DIRECT_MESH_EXTS = /* @__PURE__ */ new Set([".stl", ".obj", ".3mf"]);
 var DIRECT_STEP_EXTS = /* @__PURE__ */ new Set([".step", ".stp"]);
 var DIRECT_CAD_EXTS = /* @__PURE__ */ new Set([...DIRECT_MESH_EXTS, ...DIRECT_STEP_EXTS]);
-function directCadInputKind(path5) {
-  const ext = extname(path5).toLowerCase();
+function directCadInputKind(path7) {
+  const ext = extname(path7).toLowerCase();
   if (DIRECT_MESH_EXTS.has(ext)) return "mesh";
   if (DIRECT_STEP_EXTS.has(ext)) return "step";
   return null;
 }
-function replaceCliInputExtension(path5, newExt) {
-  const lower2 = path5.toLowerCase();
+function replaceCliInputExtension(path7, newExt) {
+  const lower2 = path7.toLowerCase();
   for (const ext of [".forge.js", ".js", ".svg", ".dxf", ...DIRECT_CAD_EXTS]) {
-    if (lower2.endsWith(ext)) return path5.slice(0, -ext.length) + newExt;
+    if (lower2.endsWith(ext)) return path7.slice(0, -ext.length) + newExt;
   }
-  return path5 + newExt;
+  return path7 + newExt;
 }
 function buildDirectCadImportScript(fileName, kind) {
   const importFn = kind === "step" ? "Import.step" : "Import.mesh";
@@ -5823,10 +5830,10 @@ function buildDirectCadImportScript(fileName, kind) {
     `return [{ name: ${JSON.stringify(objectName)}, shape: imported }];`
   ].join("\n");
 }
-function loadCliScriptInput(inputPath) {
+function loadCliScriptInput(inputPath, options = {}) {
   const sourcePath = resolve6(inputPath);
   const directCadKind = directCadInputKind(sourcePath);
-  const { projectRoot, allFiles, fileName, readBinaryFile } = collectProjectFiles(inputPath);
+  const { projectRoot, allFiles, fileName, readBinaryFile } = collectProjectFiles(inputPath, options);
   const directThreeMfAnalysis = directCadKind === "mesh" && extname(fileName).toLowerCase() === ".3mf" ? analyze3mf(readBinaryFile(fileName)) : void 0;
   if (!directCadKind) {
     return {
@@ -7787,8 +7794,8 @@ function parseHideArg(argv, idx) {
   if (values.length === 0) throw new Error("--hide requires at least one object name.");
   return { value: values, nextIndex: idx + 1 };
 }
-function replaceRenderableInputExtension(path5, newExt) {
-  return replaceCliInputExtension(path5, newExt);
+function replaceRenderableInputExtension(path7, newExt) {
+  return replaceCliInputExtension(path7, newExt);
 }
 function parseRenderCliOptions(argv) {
   if (argv.length === 0 || argv.includes("-h") || argv.includes("--help")) {
@@ -8756,8 +8763,8 @@ function collectRenderProjectFiles(scriptPath) {
     fileName: pathRelativeTo(projectRoot, absScript)
   };
 }
-function toPortablePath(path5) {
-  return path5.split("\\").join("/");
+function toPortablePath(path7) {
+  return path7.split("\\").join("/");
 }
 function pathRelativeTo(from, to) {
   const rel = relative3(from, to);
@@ -8824,10 +8831,10 @@ function readPackageVersion() {
 }
 function buildViewPathEntries(pathsByView) {
   return Object.fromEntries(
-    Object.entries(pathsByView ?? {}).map(([view, path5]) => [
+    Object.entries(pathsByView ?? {}).map(([view, path7]) => [
       view,
       {
-        path: path5
+        path: path7
       }
     ])
   );
@@ -10916,8 +10923,8 @@ function projectDesignHistory(trace, options = {}) {
 function plural(count, singular) {
   return `${count} ${singular}${count === 1 ? "" : "s"}`;
 }
-function pathLabel(path5, fallback) {
-  return path5.length > 0 ? path5.join(" > ") : fallback;
+function pathLabel(path7, fallback) {
+  return path7.length > 0 ? path7.join(" > ") : fallback;
 }
 function sourceLabel2(step) {
   if (!step.sourceSpan) return "";
@@ -11222,13 +11229,13 @@ function childPath(parent, childName, index) {
   const label = childName ?? `child ${index + 1}`;
   return parent ? `${parent}.${label}` : label;
 }
-function partShapeLeaves(part, path5 = "") {
+function partShapeLeaves(part, path7 = "") {
   if (part instanceof Shape) {
     const bbox = partBoundingBox(part);
     if (!bbox) return [];
     return [
       {
-        name: path5 || "shape",
+        name: path7 || "shape",
         shape: part,
         bbox,
         bodyCount: bodyCount(part)
@@ -11238,7 +11245,7 @@ function partShapeLeaves(part, path5 = "") {
   const leaves = [];
   part.children.forEach((child, index) => {
     if (child instanceof Shape || child instanceof ShapeGroup) {
-      leaves.push(...partShapeLeaves(child, childPath(path5, part.childName(index), index)));
+      leaves.push(...partShapeLeaves(child, childPath(path7, part.childName(index), index)));
     }
   });
   return leaves;
@@ -14061,10 +14068,10 @@ function roundVec2(point) {
 function roundVec3(point) {
   return [round2(point[0]), round2(point[1]), round2(point[2])];
 }
-function fingerprint(path5) {
+function fingerprint(path7) {
   try {
-    if (!statSync6(path5).isFile()) return null;
-    const hash = createHash("sha256").update(readFileSync8(path5)).digest("hex");
+    if (!statSync6(path7).isFile()) return null;
+    const hash = createHash("sha256").update(readFileSync8(path7)).digest("hex");
     return `sha256:${hash}`;
   } catch {
     return null;
@@ -14473,8 +14480,8 @@ function printSectionSummary(result) {
   console.log("");
   console.log(`Replay: forgecad inspect replay ${result.artifacts.resultJson} --source <candidate>`);
 }
-function readInspectionResult(path5) {
-  const resolved = resolve11(path5);
+function readInspectionResult(path7) {
+  const resolved = resolve11(path7);
   if (!existsSync7(resolved)) throw new Error(`Inspection result not found: ${resolved}`);
   const parsed = JSON.parse(readFileSync8(resolved, "utf-8"));
   if (parsed.kind !== "forgecad.inspect.section.result" || parsed.replaySpec?.tool !== "section") {
@@ -14791,20 +14798,20 @@ function selectRegion(regions, seed, operation) {
     operationCompatible: false
   };
 }
-function collectProfileUses(plan, path5 = "$") {
+function collectProfileUses(plan, path7 = "$") {
   switch (plan.kind) {
     case "extrude":
-      return [{ operation: "extrude", profile: plan.profile, path: `${path5}.profile` }];
+      return [{ operation: "extrude", profile: plan.profile, path: `${path7}.profile` }];
     case "cut":
-      return [...collectProfileUses(plan.base, `${path5}.base`), { operation: "cut", profile: plan.profile, path: `${path5}.profile` }];
+      return [...collectProfileUses(plan.base, `${path7}.base`), { operation: "cut", profile: plan.profile, path: `${path7}.profile` }];
     case "revolve":
-      return [{ operation: "revolve", profile: plan.profile, path: `${path5}.profile` }];
+      return [{ operation: "revolve", profile: plan.profile, path: `${path7}.profile` }];
     case "queryOwner":
-      return collectProfileUses(plan.base, `${path5}.base`);
+      return collectProfileUses(plan.base, `${path7}.base`);
     case "transform":
-      return collectProfileUses(plan.base, `${path5}.base`);
+      return collectProfileUses(plan.base, `${path7}.base`);
     case "boolean":
-      return plan.shapes.flatMap((shape, index) => collectProfileUses(shape, `${path5}.shapes[${index}]`));
+      return plan.shapes.flatMap((shape, index) => collectProfileUses(shape, `${path7}.shapes[${index}]`));
     case "shell":
     case "hole":
     case "trimByPlane":
@@ -14817,32 +14824,32 @@ function collectProfileUses(plan, path5 = "$") {
     case "surfaceExtend":
     case "surfaceThicken":
     case "surfaceSolid":
-      return collectProfileUses(plan.base, `${path5}.base`);
+      return collectProfileUses(plan.base, `${path7}.base`);
     case "surfaceSew":
-      return plan.shapes.flatMap((shape, index) => collectProfileUses(shape, `${path5}.shapes[${index}]`));
+      return plan.shapes.flatMap((shape, index) => collectProfileUses(shape, `${path7}.shapes[${index}]`));
     default:
       return [];
   }
 }
-function summarizeProfilePlan(plan, path5) {
+function summarizeProfilePlan(plan, path7) {
   switch (plan.kind) {
     case "boolean":
       return {
-        path: path5,
+        path: path7,
         kind: plan.kind,
         op: plan.op,
-        children: plan.profiles.map((profile, index) => summarizeProfilePlan(profile, `${path5}.profiles[${index}]`))
+        children: plan.profiles.map((profile, index) => summarizeProfilePlan(profile, `${path7}.profiles[${index}]`))
       };
     case "offset":
-      return { path: path5, kind: plan.kind, children: [summarizeProfilePlan(plan.base, `${path5}.base`)] };
+      return { path: path7, kind: plan.kind, children: [summarizeProfilePlan(plan.base, `${path7}.base`)] };
     case "project":
       return {
-        path: path5,
+        path: path7,
         kind: plan.kind,
-        children: plan.replayProfile ? [summarizeProfilePlan(plan.replayProfile, `${path5}.replayProfile`)] : []
+        children: plan.replayProfile ? [summarizeProfilePlan(plan.replayProfile, `${path7}.replayProfile`)] : []
       };
     default:
-      return { path: path5, kind: plan.kind, children: [] };
+      return { path: path7, kind: plan.kind, children: [] };
   }
 }
 function readSketchBounds(sketch, diagnostics) {
@@ -17315,12 +17322,12 @@ var ESTABLISHED_LOWERCASE_PUBLIC_API_GLOBALS = /* @__PURE__ */ new Set([
   "require"
 ]);
 function readText(relativePath) {
-  const path5 = resolvePackagePath(import.meta.url, relativePath);
-  return readFileSync9(path5, "utf8");
+  const path7 = resolvePackagePath(import.meta.url, relativePath);
+  return readFileSync9(path7, "utf8");
 }
 function readSource(relativePath) {
-  const path5 = resolvePackagePath(import.meta.url, relativePath);
-  return ts.createSourceFile(path5, readText(relativePath), ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
+  const path7 = resolvePackagePath(import.meta.url, relativePath);
+  return ts.createSourceFile(path7, readText(relativePath), ts.ScriptTarget.Latest, true, ts.ScriptKind.TS);
 }
 function propertyNameText(name) {
   if (ts.isIdentifier(name) || ts.isStringLiteral(name) || ts.isNumericLiteral(name)) return name.text;
@@ -17595,8 +17602,8 @@ function parseArgs4(argv) {
   requireScriptInputPaths(inputPaths);
   return { inputPaths, json, compact, noFailExit, paramOverrides, jointOverrides };
 }
-function finding2(code, message, path5) {
-  return { level: "error", code, message, path: path5 };
+function finding2(code, message, path7) {
+  return { level: "error", code, message, path: path7 };
 }
 function failedReport(source, modelName, errorMessage2, code = "SIM.CHECK.ERROR") {
   const errors = [finding2(code, errorMessage2)];
@@ -17616,8 +17623,8 @@ function resolveSimulationModel(result, jointOverrides) {
   return collectSimulationModel(assembly2.describe(), { state: jointOverrides });
 }
 function renderFinding(finding3) {
-  const path5 = finding3.path ? ` (${finding3.path})` : "";
-  return `  - [${finding3.code}] ${finding3.message}${path5}`;
+  const path7 = finding3.path ? ` (${finding3.path})` : "";
+  return `  - [${finding3.code}] ${finding3.message}${path7}`;
 }
 function printHuman3(report) {
   if (report.ok) {
@@ -18076,8 +18083,8 @@ function renderFeedbackText(report) {
   for (const finding3 of report.findings) {
     const glyph = finding3.level === "error" ? "\u2717" : finding3.level === "warning" ? "\u26A0" : "\xB7";
     const suggest = finding3.suggest ? ` \u2192 ${finding3.suggest}` : "";
-    const path5 = finding3.path ? ` (${finding3.path})` : "";
-    lines.push(`  ${glyph} [${finding3.code}] ${finding3.message}${path5}${suggest}`);
+    const path7 = finding3.path ? ` (${finding3.path})` : "";
+    lines.push(`  ${glyph} [${finding3.code}] ${finding3.message}${path7}${suggest}`);
   }
   if (report.trust.assumptions.length > 0) {
     lines.push(`  assumptions: ${report.trust.assumptions.join("; ")}`);
@@ -18882,10 +18889,10 @@ function commandPatternMatches(pattern, commandPath) {
   if (pattern.length === 0 || pattern.length > commandPath.length) return false;
   return pattern.every((part, index) => part === commandPath[index]);
 }
-function readForgeCadCliConfig(path5 = defaultConfigPath()) {
-  if (!existsSync8(path5)) return null;
-  const parsed = JSON.parse(readFileSync11(path5, "utf-8"));
-  return { config: parsed, path: path5 };
+function readForgeCadCliConfig(path7 = defaultConfigPath()) {
+  if (!existsSync8(path7)) return null;
+  const parsed = JSON.parse(readFileSync11(path7, "utf-8"));
+  return { config: parsed, path: path7 };
 }
 function disabledCommandMatch(commandPath, loaded = readForgeCadCliConfig()) {
   const command = commandPath.join(" ");
@@ -19288,20 +19295,20 @@ async function buildBrepBlob(objects) {
     }
     topoShape = compound;
   }
-  const path5 = "/tmp/forgecad-export.brep";
+  const path7 = "/tmp/forgecad-export.brep";
   const pr = new oc.Message_ProgressRange_1();
-  const writeSuccess = oc.BRepTools.Write_3(topoShape, path5, pr);
+  const writeSuccess = oc.BRepTools.Write_3(topoShape, path7, pr);
   if (!writeSuccess) {
     throw new Error("BREP export: BRepTools.Write_3 returned failure.");
   }
   let data;
   try {
-    data = oc.FS.readFile(path5);
+    data = oc.FS.readFile(path7);
   } catch (err) {
     throw new Error(`BREP export: failed to read written file from virtual FS \u2014 ${err.message || err}`);
   }
   try {
-    oc.FS.unlink(path5);
+    oc.FS.unlink(path7);
   } catch {
   }
   return new Blob([data.buffer], { type: "application/octet-stream" });
@@ -19980,9 +19987,9 @@ function readValue4(argv, idx, flag) {
   }
   return next;
 }
-function inferFormatFromPath(path5) {
-  if (!path5) return null;
-  const ext = extname4(path5).toLowerCase();
+function inferFormatFromPath(path7) {
+  if (!path7) return null;
+  const ext = extname4(path7).toLowerCase();
   if (ext === ".gif") return "gif";
   if (ext === ".mp4") return "mp4";
   return null;
@@ -21395,9 +21402,9 @@ function normalizeFeaArtifactDigest(value, label) {
 function normalizeFeaArtifactDigestMap(value, label) {
   if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${label} must be an object`);
   const map = {};
-  for (const [path5, digest] of Object.entries(value)) {
-    if (!path5.trim()) throw new Error(`${label} cannot contain an empty path`);
-    map[path5] = normalizeFeaArtifactDigest(digest, `${label}.${path5}`);
+  for (const [path7, digest] of Object.entries(value)) {
+    if (!path7.trim()) throw new Error(`${label} cannot contain an empty path`);
+    map[path7] = normalizeFeaArtifactDigest(digest, `${label}.${path7}`);
   }
   return map;
 }
@@ -24127,8 +24134,8 @@ function parseGmshMsh41SurfaceMesh(text, surfaceEntityIds) {
   if (triangles.length === 0) throw new Error("Gmsh MSH contains no exterior surface triangles for FEA deformed rendering.");
   return { nodes, triangles, surfaceElements };
 }
-function readJson(packageDir, path5) {
-  return requireRecord(JSON.parse(readFileSync17(join9(packageDir, path5), "utf-8")), path5);
+function readJson(packageDir, path7) {
+  return requireRecord(JSON.parse(readFileSync17(join9(packageDir, path7), "utf-8")), path7);
 }
 function deformedPosition(base, displacement, scaleFactor) {
   return add2(base, scale2(displacement, scaleFactor));
@@ -24235,8 +24242,8 @@ function positiveFiniteNumber(value, label) {
   }
   return value;
 }
-function readPackageJson(packageDir, path5) {
-  return JSON.parse(readFileSync18(join10(packageDir, path5), "utf-8"));
+function readPackageJson(packageDir, path7) {
+  return JSON.parse(readFileSync18(join10(packageDir, path7), "utf-8"));
 }
 function packageYieldStrengthMpa(packageDir) {
   const manifest = readPackageJson(packageDir, "fea-manifest.json");
@@ -25599,9 +25606,9 @@ function fileStemForObject(name) {
 function defaultOutputPath4(scriptPath, format) {
   return replaceCliInputExtension(scriptPath, format === "json" ? ".implicit.json" : ".implicit-webgpu");
 }
-function writeJsonFile(path5, value) {
-  mkdirSync6(dirname6(path5), { recursive: true });
-  writeFileSync11(path5, `${JSON.stringify(value, null, 2)}
+function writeJsonFile(path7, value) {
+  mkdirSync6(dirname6(path7), { recursive: true });
+  writeFileSync11(path7, `${JSON.stringify(value, null, 2)}
 `, "utf-8");
 }
 async function runImplicitExportCli(argv = process.argv.slice(2)) {
@@ -29695,19 +29702,19 @@ function requireMetricValue(report, key) {
   if (value === null) throw new Error(`Solved structural FEA feedback is missing finite metric ${key}`);
   return value;
 }
-function requireDigest(map, path5, label) {
-  const digest = map[path5];
-  if (!digest) throw new Error(`fea-manifest.json artifactDigests is missing ${label} (${path5}).`);
+function requireDigest(map, path7, label) {
+  const digest = map[path7];
+  if (!digest) throw new Error(`fea-manifest.json artifactDigests is missing ${label} (${path7}).`);
   return digest;
 }
-function requireActualDigest(map, path5, label) {
-  const digest = map[path5];
-  if (!digest) throw new Error(`actual package artifact digest is missing ${label} (${path5}).`);
+function requireActualDigest(map, path7, label) {
+  const digest = map[path7];
+  if (!digest) throw new Error(`actual package artifact digest is missing ${label} (${path7}).`);
   return digest;
 }
-function requirePackageDigestMatch(expected, actual, path5, label) {
-  const expectedDigest = requireDigest(expected, path5, label);
-  requireMatchingFeaArtifactDigest(requireActualDigest(actual, path5, label), expectedDigest, label);
+function requirePackageDigestMatch(expected, actual, path7, label) {
+  const expectedDigest = requireDigest(expected, path7, label);
+  requireMatchingFeaArtifactDigest(requireActualDigest(actual, path7, label), expectedDigest, label);
   return expectedDigest;
 }
 function resolveStructuralStressPackageDigests(manifestArtifactDigests, actualArtifactDigests, paths) {
@@ -29726,8 +29733,8 @@ function resolveStructuralStressPackageDigests(manifestArtifactDigests, actualAr
     } : {}
   };
 }
-function requireArtifactDigestForPath(digests, path5, label) {
-  return requirePackageDigestMatch(digests.expected, digests.actual, path5, label);
+function requireArtifactDigestForPath(digests, path7, label) {
+  return requirePackageDigestMatch(digests.expected, digests.actual, path7, label);
 }
 function requireFeedbackMetricMatches(report, key, value) {
   const feedbackValue = requireMetricValue(report, key);
@@ -29977,15 +29984,15 @@ function failedReport4(source, message, code, suggest) {
     timeMs: 0
   };
 }
-function readPackageJson2(packageDir, path5) {
-  return JSON.parse(readFileSync22(join16(packageDir, path5), "utf-8"));
+function readPackageJson2(packageDir, path7) {
+  return JSON.parse(readFileSync22(join16(packageDir, path7), "utf-8"));
 }
 function digestPackageArtifacts(packageDir, manifest) {
   const declared = manifest.artifactDigests;
   if (!declared || typeof declared !== "object" || Array.isArray(declared)) return {};
   const digests = {};
-  for (const path5 of Object.keys(declared)) {
-    digests[path5] = digestFeaArtifactBytes(readFileSync22(join16(packageDir, path5)));
+  for (const path7 of Object.keys(declared)) {
+    digests[path7] = digestFeaArtifactBytes(readFileSync22(join16(packageDir, path7)));
   }
   return digests;
 }
@@ -31954,6 +31961,7 @@ async function exportSketchPdfInput(scriptPath, explicitOutputPath, paramOverrid
 import { cpSync, existsSync as existsSync17, mkdirSync as mkdirSync9, readdirSync as readdirSync6, readFileSync as readFileSync24, rmSync as rmSync4, writeFileSync as writeFileSync16 } from "fs";
 import { homedir as homedir6 } from "os";
 import { extname as extname12, join as join17, relative as relative5, resolve as resolve40 } from "path";
+import { createInterface } from "readline";
 var INSTALL_TARGETS = {
   agents: { label: "agent-compatible", root: join17(homedir6(), ".agents", "skills") },
   claude: { label: "Claude Code", root: join17(homedir6(), ".claude", "skills") },
@@ -31962,27 +31970,6 @@ var INSTALL_TARGETS = {
 };
 var ALL_INSTALL_TARGETS = Object.keys(INSTALL_TARGETS);
 var DEFAULT_INSTALL_TARGET = "agents";
-var RETIRED_COMPANION_SKILL_NAMES = [
-  "forgecad-3d-reconstruction",
-  "forgecad-assembly-contract",
-  "forgecad-benchmark-reconstruction",
-  "forgecad-blockout",
-  "forgecad-blockout-model",
-  "forgecad-component-model",
-  "forgecad-high-level-spec",
-  "forgecad-image-replicator",
-  "forgecad-lld",
-  "forgecad-make-a-model",
-  "forgecad-model-grader",
-  "forgecad-mujoco-verify",
-  "forgecad-prepare-prompt",
-  "forgecad-project",
-  "forgecad-reconstruction-benchmark",
-  "forgecad-render-inspect",
-  "forgecad-spec-by-walking-through-it",
-  "forgecad-visual-prompt",
-  "forgecad-visual-spec"
-];
 function installUsage() {
   return [
     "Usage: forgecad skill install [--target agents|claude|codex|opencode|all] [--core-only]",
@@ -32073,7 +32060,39 @@ If you are running from a source checkout, run: npm run build:skill:forgecad`
   console.log(`ForgeCAD skill installed to ${dest} [standard model authoring]`);
   return dest;
 }
-function installCompanionLibrary(targetRoot) {
+function confirm(question) {
+  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  return new Promise((resolve54) => {
+    rl.question(`${question} [y/N] `, (answer) => {
+      rl.close();
+      resolve54(/^(y|yes)$/i.test(answer.trim()));
+    });
+  });
+}
+function discoverCompanionSkillNames(srcLibrary) {
+  return readdirSync6(srcLibrary, { withFileTypes: true }).filter((entry) => entry.isDirectory() && existsSync17(join17(srcLibrary, entry.name, "SKILL.md"))).map((entry) => entry.name).sort();
+}
+function findStaleForgeCadCompanionSkillNames(targetRoot, currentSkillNames) {
+  if (!existsSync17(targetRoot)) return [];
+  return readdirSync6(targetRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name).filter((name) => name.startsWith("forgecad-")).filter((name) => !currentSkillNames.has(name)).filter((name) => existsSync17(join17(targetRoot, name, "SKILL.md"))).sort();
+}
+async function removeConfirmedStaleCompanionSkills(targetRoot, currentSkillNames) {
+  const staleNames = findStaleForgeCadCompanionSkillNames(targetRoot, currentSkillNames);
+  if (staleNames.length === 0) return;
+  console.warn(`Found ForgeCAD-named skill directories that are not in this package at ${targetRoot}:`);
+  for (const name of staleNames) console.warn(`  - ${name}`);
+  if (!process.stdin.isTTY || !process.stderr.isTTY) {
+    console.warn("Skipping stale skill cleanup because this shell is not interactive. Delete them manually or rerun in a terminal.");
+    return;
+  }
+  if (!await confirm("Remove these stale ForgeCAD companion skill directories?")) {
+    console.log("Skipped stale ForgeCAD companion skill cleanup.");
+    return;
+  }
+  for (const name of staleNames) rmSync4(join17(targetRoot, name), { recursive: true, force: true });
+  console.log(`Removed ${staleNames.length} stale ForgeCAD companion skill${staleNames.length === 1 ? "" : "s"}.`);
+}
+async function installCompanionLibrary(targetRoot) {
   const srcLibrary = resolvePackagePath(import.meta.url, "dist-skill", "library");
   if (!existsSync17(srcLibrary)) {
     throw new Error(
@@ -32082,17 +32101,15 @@ If you are running from a source checkout, run: npm run build:skill:forgecad`
     );
   }
   mkdirSync9(targetRoot, { recursive: true });
-  for (const name of RETIRED_COMPANION_SKILL_NAMES) {
-    rmSync4(join17(targetRoot, name), { recursive: true, force: true });
-  }
+  const currentSkillNames = discoverCompanionSkillNames(srcLibrary);
+  await removeConfirmedStaleCompanionSkills(targetRoot, new Set(currentSkillNames));
   const installed = [];
-  for (const entry of readdirSync6(srcLibrary, { withFileTypes: true })) {
-    if (!entry.isDirectory()) continue;
-    const src = join17(srcLibrary, entry.name);
-    const dest = join17(targetRoot, entry.name);
+  for (const name of currentSkillNames) {
+    const src = join17(srcLibrary, name);
+    const dest = join17(targetRoot, name);
     rmSync4(dest, { recursive: true, force: true });
     cpSync(src, dest, { recursive: true });
-    installed.push(entry.name);
+    installed.push(name);
   }
   if (installed.length === 0) {
     throw new Error(`No companion skills found in ${srcLibrary}`);
@@ -32107,7 +32124,7 @@ async function runSkillInstallCli(argv = []) {
     const config = INSTALL_TARGETS[target];
     console.log(`Installing ForgeCAD skills for ${config.label} at ${config.root}`);
     installCoreSkill(config.root);
-    if (options.includeLibrary) installCompanionLibrary(config.root);
+    if (options.includeLibrary) await installCompanionLibrary(config.root);
   }
   console.log(`Reload your agent (Claude Code, Codex, OpenCode, \u2026) to activate.`);
 }
@@ -32129,11 +32146,11 @@ If you are running from a source checkout, run: npm run build:skill:forgecad`
   console.log(`ForgeCAD context written to ${dest}`);
   console.log(`Paste the contents into any AI chat UI (Claude.ai, ChatGPT, Gemini, \u2026) to get full ForgeCAD API knowledge.`);
 }
-function normalizeRelativePath(path5) {
-  return path5.replace(/\\/g, "/");
+function normalizeRelativePath(path7) {
+  return path7.replace(/\\/g, "/");
 }
-function languageForPath(path5) {
-  const ext = extname12(path5).toLowerCase();
+function languageForPath(path7) {
+  const ext = extname12(path7).toLowerCase();
   if (ext === ".js" || ext === ".mjs" || ext === ".cjs") return "js";
   if (ext === ".ts" || ext === ".tsx") return "ts";
   if (ext === ".json") return "json";
@@ -32165,8 +32182,8 @@ function findSkillFiles(root) {
     return a.label.localeCompare(b.label);
   });
 }
-function renderFlattenedFile(label, path5, isFirst) {
-  const raw = readFileSync24(path5, "utf-8").trimEnd().replaceAll("{{SKILL_DIR}}/", "").replaceAll("{{SKILL_DIR}}", ".");
+function renderFlattenedFile(label, path7, isFirst) {
+  const raw = readFileSync24(path7, "utf-8").trimEnd().replaceAll("{{SKILL_DIR}}/", "").replaceAll("{{SKILL_DIR}}", ".");
   if (isFirst) return raw;
   if (label.endsWith(".md")) {
     return [`## File: \`${label}\``, "", raw].join("\n");
@@ -32239,9 +32256,9 @@ import { resolve as resolve41 } from "path";
 
 // cli/forge-studio-server.ts
 import chokidar from "chokidar";
-import fs2 from "fs";
+import fs3 from "fs";
 import http from "http";
-import path3 from "path";
+import path4 from "path";
 
 // server/importAnalysis.ts
 var FORGE_IMPORT_RE2 = /\b(?:importMesh|importStep|importSvgSketch|Import\.mesh|Import\.step|Import\.svgSketch|Import\.dxfSketch)\s*\(\s*(?:"([^"]+)"|'([^']+)')/g;
@@ -32269,19 +32286,19 @@ function extractImports2(code) {
   let m;
   const forgeRe = new RegExp(FORGE_IMPORT_RE2.source, FORGE_IMPORT_RE2.flags);
   while ((m = forgeRe.exec(code)) !== null) {
-    const path5 = m[1] ?? m[2];
+    const path7 = m[1] ?? m[2];
     const fn = m[0].match(/\b(importMesh|importStep|importSvgSketch|Import\.mesh|Import\.step|Import\.svgSketch|Import\.dxfSketch)/)?.[1];
-    add3(path5, kindMap[fn] ?? "forgeMesh");
+    add3(path7, kindMap[fn] ?? "forgeMesh");
   }
   const reqRe = new RegExp(REQUIRE_RE2.source, REQUIRE_RE2.flags);
   while ((m = reqRe.exec(code)) !== null) {
-    const path5 = m[1] ?? m[2];
-    add3(path5, "require");
+    const path7 = m[1] ?? m[2];
+    add3(path7, "require");
   }
   const esRe = new RegExp(ES_IMPORT_RE2.source, ES_IMPORT_RE2.flags);
   while ((m = esRe.exec(code)) !== null) {
-    const path5 = m[1] ?? m[2];
-    add3(path5, "esImport");
+    const path7 = m[1] ?? m[2];
+    add3(path7, "esImport");
   }
   return refs;
 }
@@ -32350,7 +32367,7 @@ import { join as join19 } from "path";
 import { chmodSync as chmodSync2, existsSync as existsSync18, mkdirSync as mkdirSync10, readFileSync as readFileSync25, unlinkSync, writeFileSync as writeFileSync17 } from "fs";
 import { homedir as homedir7 } from "os";
 import { join as join18 } from "path";
-import { createInterface } from "readline";
+import { createInterface as createInterface2 } from "readline";
 
 // cli/server-url.ts
 import { execFile, execFileSync } from "child_process";
@@ -32396,14 +32413,14 @@ function normalizeServerUrl(raw, label = "Server URL") {
 function isOfficialServerUrl(server) {
   return normalizeServerUrl(server) === DEFAULT_SERVER;
 }
-function requireRelativeApiPath(path5) {
-  if (!path5.startsWith("/") || path5.startsWith("//") || /^[a-z][a-z0-9+.-]*:/i.test(path5)) {
+function requireRelativeApiPath(path7) {
+  if (!path7.startsWith("/") || path7.startsWith("//") || /^[a-z][a-z0-9+.-]*:/i.test(path7)) {
     throw new Error("Authenticated ForgeCAD requests must use a relative API path.");
   }
-  return path5;
+  return path7;
 }
-function serverUrlWithPath(server, path5) {
-  return `${normalizeServerUrl(server)}${requireRelativeApiPath(path5)}`;
+function serverUrlWithPath(server, path7) {
+  return `${normalizeServerUrl(server)}${requireRelativeApiPath(path7)}`;
 }
 function normalizeBrowserUrl(raw) {
   const url = parseUrl(raw, "Browser URL");
@@ -32493,7 +32510,7 @@ function getEnvToken() {
   return { token, server: normalizeServerUrl(process.env.FORGECAD_SERVER ?? DEFAULT_SERVER, "FORGECAD_SERVER") };
 }
 function prompt(question) {
-  const rl = createInterface({ input: process.stdin, output: process.stderr });
+  const rl = createInterface2({ input: process.stdin, output: process.stderr });
   return new Promise((resolve54) => {
     rl.question(question, (answer) => {
       rl.close();
@@ -32684,8 +32701,8 @@ async function refreshTokens(auth) {
     return null;
   }
 }
-async function authenticatedFetch(path5, init2) {
-  const apiPath = requireRelativeApiPath(path5);
+async function authenticatedFetch(path7, init2) {
+  const apiPath = requireRelativeApiPath(path7);
   const envToken = getEnvToken();
   if (envToken) {
     const url = serverUrlWithPath(envToken.server, apiPath);
@@ -32816,6 +32833,19 @@ function requireManifest(projectDir) {
   }
   return m;
 }
+function hasRemoteProject(manifest) {
+  return typeof manifest.projectId === "string" && manifest.projectId.length > 0;
+}
+function requireRemoteManifest(projectDir, action = "use this command") {
+  const manifest = requireManifest(projectDir);
+  if (!hasRemoteProject(manifest)) {
+    throw new Error(
+      `This ForgeCAD project has not been created on the server yet.
+  Run \`forgecad project push\` to create the hosted project, then ${action}.`
+    );
+  }
+  return manifest;
+}
 function contentHash(content) {
   return createHash2("sha256").update(content, "utf-8").digest("hex").slice(0, 16);
 }
@@ -32839,14 +32869,14 @@ function scanLocalFiles(projectDir) {
   return files;
 }
 function remoteFilesFromInit(entries) {
-  return Object.entries(entries).map(([path5, content]) => ({
-    path: path5,
+  return Object.entries(entries).map(([path7, content]) => ({
+    path: path7,
     content,
     hash: contentHash(content)
   }));
 }
-function projectPathLeaf(path5) {
-  return path5.split("/").pop() ?? path5;
+function projectPathLeaf(path7) {
+  return path7.split("/").pop() ?? path7;
 }
 function findProjectMoveCandidates(fromPath, remoteFile, untracked) {
   const fromLeaf = projectPathLeaf(fromPath);
@@ -32875,17 +32905,17 @@ function diffFiles(local, remote) {
   const remoteMap = new Map(remote.map((f2) => [f2.path, f2]));
   const allPaths = /* @__PURE__ */ new Set([...localMap.keys(), ...remoteMap.keys()]);
   const diffs = [];
-  for (const path5 of allPaths) {
-    const l = localMap.get(path5);
-    const r = remoteMap.get(path5);
+  for (const path7 of allPaths) {
+    const l = localMap.get(path7);
+    const r = remoteMap.get(path7);
     if (l && !r) {
-      diffs.push({ path: path5, status: "added" });
+      diffs.push({ path: path7, status: "added" });
     } else if (!l && r) {
-      diffs.push({ path: path5, status: "deleted" });
+      diffs.push({ path: path7, status: "deleted" });
     } else if (l && r && l.hash !== r.hash) {
-      diffs.push({ path: path5, status: "modified" });
+      diffs.push({ path: path7, status: "modified" });
     } else {
-      diffs.push({ path: path5, status: "unchanged" });
+      diffs.push({ path: path7, status: "unchanged" });
     }
   }
   return diffs.sort((a, b) => a.path.localeCompare(b.path));
@@ -33086,7 +33116,7 @@ import { existsSync as existsSync20, readdirSync as readdirSync8, statSync as st
 import { createServer as createServer2 } from "net";
 import { join as join20 } from "path";
 var startedComputeServer = null;
-var REQUIRED_ENGINE_VERSION = "native-occt-node-api-0.3.1";
+var REQUIRED_ENGINE_VERSION = "backend-ir-node-api-0.1.0";
 var REQUIRED_PLAN_KINDS = [
   "box",
   "cylinder",
@@ -33119,12 +33149,14 @@ async function isHealthy(computeUrl) {
     const response = await fetch(`${computeUrl}/health`, { signal: AbortSignal.timeout(1e3) });
     if (!response.ok) return false;
     const body = await response.json().catch(() => null);
-    if (body?.status !== "ok" || body?.nativeOcctAvailable !== true || body?.engineVersion !== REQUIRED_ENGINE_VERSION) return false;
+    if (body?.status !== "ok" || body?.engineVersion !== REQUIRED_ENGINE_VERSION) return false;
+    if (body?.nativeOcctAvailable !== true && body?.sdfAvailable !== true) return false;
     const capabilitiesResponse = await fetch(`${computeUrl}/capabilities`, { signal: AbortSignal.timeout(1e3) });
     if (!capabilitiesResponse.ok) return false;
     const capabilities = await capabilitiesResponse.json().catch(() => null);
     const supportedKinds = capabilities?.nativeOcct?.supportedPlanKinds;
-    return Array.isArray(supportedKinds) && REQUIRED_PLAN_KINDS.every((kind) => supportedKinds.includes(kind));
+    const supportedSdfKinds = capabilities?.sdf?.supportedPlanKinds;
+    return Array.isArray(supportedKinds) && REQUIRED_PLAN_KINDS.every((kind) => supportedKinds.includes(kind)) && Array.isArray(supportedSdfKinds) && supportedSdfKinds.includes("sdf");
   } catch {
     return false;
   }
@@ -33135,7 +33167,7 @@ async function waitForHealthy(computeUrl, child) {
     if (child.exitCode != null) break;
     await new Promise((resolve54) => setTimeout(resolve54, 50));
   }
-  throw new Error(`Native OCCT compute backend did not become healthy at ${computeUrl}.`);
+  throw new Error(`Backend compute server did not become healthy at ${computeUrl}.`);
 }
 function closeChild(child) {
   return new Promise((resolve54) => {
@@ -33150,13 +33182,13 @@ function closeChild(child) {
 function hasLocalNativeComputeSource(packageRoot) {
   return existsSync20(join20(packageRoot, "apps/backend/src/server.ts")) && existsSync20(join20(packageRoot, "scripts/build-native-occt.mjs"));
 }
-function newestMtimeMs(path5) {
-  if (!existsSync20(path5)) return 0;
-  const stat = statSync11(path5);
+function newestMtimeMs(path7) {
+  if (!existsSync20(path7)) return 0;
+  const stat = statSync11(path7);
   if (!stat.isDirectory()) return stat.mtimeMs;
   let newest = stat.mtimeMs;
-  for (const entry of readdirSync8(path5, { withFileTypes: true })) {
-    newest = Math.max(newest, newestMtimeMs(join20(path5, entry.name)));
+  for (const entry of readdirSync8(path7, { withFileTypes: true })) {
+    newest = Math.max(newest, newestMtimeMs(join20(path7, entry.name)));
   }
   return newest;
 }
@@ -33192,7 +33224,7 @@ async function pickComputeUrl(preferred) {
     } catch {
     }
   }
-  throw new Error(`No local port available for native OCCT compute near ${preferred.href}.`);
+  throw new Error(`No local port available for backend compute near ${preferred.href}.`);
 }
 function startLocalNativeComputeServer(options) {
   if (startedComputeServer) return startedComputeServer;
@@ -33227,7 +33259,7 @@ function startLocalNativeComputeServer(options) {
     const selected = new URL(computeUrl);
     const port = selected.port || (selected.protocol === "https:" ? "443" : "80");
     const host = listenHostForUrl(selected);
-    console.log(`[compute] Starting native OCCT backend at ${computeUrl}`);
+    console.log(`[compute] Starting backend compute server at ${computeUrl}`);
     const child = spawn3("npx", ["tsx", "apps/backend/src/server.ts"], {
       cwd: options.packageRoot,
       env: { ...process.env, FORGE_BACKEND_PORT: port, FORGE_BACKEND_HOST: host },
@@ -33528,6 +33560,279 @@ function updateLocalAgentContextLatestBundle(projectRoot, filePath, latestBundle
   return next;
 }
 
+// cli/manual-param-edits-storage.ts
+import fs2 from "fs";
+import path3 from "path";
+
+// src/studio/manual-params/schema.ts
+var MANUAL_PARAM_EDITS_DRAFT_KIND = "forgecad.manualParamEditsDraft.v1";
+var MANUAL_PARAM_EDITS_KIND = "forgecad.manualParamEdits.v1";
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function requireString4(value, label) {
+  if (typeof value !== "string" || value.trim() === "") throw new Error(`Invalid manual edits ${label}`);
+  return value.trim();
+}
+function optionalString3(value) {
+  if (value == null) return void 0;
+  if (typeof value !== "string") throw new Error("Invalid manual edits unit");
+  const trimmed = value.trim();
+  return trimmed === "" ? void 0 : trimmed;
+}
+function requireFiniteNumber2(value, label) {
+  if (typeof value !== "number" || !Number.isFinite(value)) throw new Error(`Invalid manual edits ${label}`);
+  return value;
+}
+function requireInteger(value, label) {
+  const number = requireFiniteNumber2(value, label);
+  if (!Number.isInteger(number)) throw new Error(`Invalid manual edits ${label}`);
+  return number;
+}
+function parseFilePath(value) {
+  const filePath = requireString4(value, "filePath").replace(/\\/g, "/");
+  const parts = filePath.split("/");
+  if (filePath.startsWith("/") || parts.some((part) => part === "" || part === "." || part === "..") || filePath.includes("\0")) {
+    throw new Error("Invalid manual edits filePath");
+  }
+  return filePath;
+}
+function parseContinuity(value, label) {
+  if (value === "G0" || value === "G1" || value === "G2") return value;
+  throw new Error(`Invalid manual edits ${label}`);
+}
+function parsePlacementRuleMode(value, label) {
+  if (value === "allow" || value === "warn" || value === "prevent") return value;
+  throw new Error(`Invalid manual edits ${label}`);
+}
+function parseOverrides(value) {
+  if (!isRecord2(value)) throw new Error("Invalid manual edits overrides");
+  const overrides = {};
+  for (const [key, rawValue] of Object.entries(value)) {
+    if (typeof rawValue !== "number" && typeof rawValue !== "string") throw new Error(`Invalid manual edits overrides.${key}`);
+    if (typeof rawValue === "number" && !Number.isFinite(rawValue)) throw new Error(`Invalid manual edits overrides.${key}`);
+    overrides[key] = rawValue;
+  }
+  return Object.fromEntries(Object.entries(overrides).sort(([a], [b]) => a.localeCompare(b)));
+}
+function parsePathPoint(value, label) {
+  if (!isRecord2(value)) throw new Error(`Invalid manual edits ${label}`);
+  return {
+    x: requireFiniteNumber2(value.x, `${label}.x`),
+    y: requireFiniteNumber2(value.y, `${label}.y`)
+  };
+}
+function parseSplinePoint(value, label) {
+  const point = parsePathPoint(value, label);
+  return { ...point, g: parseContinuity(isRecord2(value) ? value.g : void 0, `${label}.g`) };
+}
+function parsePlacementFootprint(value, label) {
+  if (!isRecord2(value)) throw new Error(`Invalid manual edits ${label}`);
+  const type = requireString4(value.type, `${label}.type`);
+  if (type === "rect") {
+    return {
+      type,
+      width: requireFiniteNumber2(value.width, `${label}.width`),
+      height: requireFiniteNumber2(value.height, `${label}.height`)
+    };
+  }
+  if (type === "circle") {
+    return { type, radius: requireFiniteNumber2(value.radius, `${label}.radius`) };
+  }
+  throw new Error(`Invalid manual edits ${label}.type`);
+}
+function parsePlacementFrame(value, label) {
+  if (!isRecord2(value)) throw new Error(`Invalid manual edits ${label}`);
+  return {
+    center: parsePathPoint(value.center, `${label}.center`),
+    width: requireFiniteNumber2(value.width, `${label}.width`),
+    height: requireFiniteNumber2(value.height, `${label}.height`)
+  };
+}
+function parsePlacementZone(value, label) {
+  if (!isRecord2(value)) throw new Error(`Invalid manual edits ${label}`);
+  return {
+    ...parsePlacementFrame(value, label),
+    id: requireString4(value.id, `${label}.id`),
+    label: optionalString3(value.label)
+  };
+}
+function parsePlacementRules(value, label) {
+  if (!isRecord2(value)) throw new Error(`Invalid manual edits ${label}`);
+  return {
+    bounds: parsePlacementRuleMode(value.bounds, `${label}.bounds`),
+    collisions: parsePlacementRuleMode(value.collisions, `${label}.collisions`),
+    snap: requireFiniteNumber2(value.snap, `${label}.snap`)
+  };
+}
+function parsePlacementItem(value, label) {
+  if (!isRecord2(value)) throw new Error(`Invalid manual edits ${label}`);
+  return {
+    id: requireString4(value.id, `${label}.id`),
+    label: optionalString3(value.label),
+    footprint: parsePlacementFootprint(value.footprint, `${label}.footprint`),
+    x: requireFiniteNumber2(value.x, `${label}.x`),
+    y: requireFiniteNumber2(value.y, `${label}.y`),
+    angle: requireFiniteNumber2(value.angle, `${label}.angle`),
+    zone: optionalString3(value.zone),
+    locked: value.locked === void 0 ? void 0 : Boolean(value.locked)
+  };
+}
+function parseManualParam(value, label) {
+  if (!isRecord2(value)) throw new Error(`Invalid manual edits ${label}`);
+  const kind = requireString4(value.kind, `${label}.kind`);
+  const name = requireString4(value.name, `${label}.name`);
+  if (kind === "path2d") {
+    const minPoints = requireInteger(value.minPoints, `${label}.minPoints`);
+    const maxPoints = requireInteger(value.maxPoints, `${label}.maxPoints`);
+    if (minPoints < 0 || maxPoints < minPoints) throw new Error(`Invalid manual edits ${label} point range`);
+    if (!Array.isArray(value.points)) throw new Error(`Invalid manual edits ${label}.points`);
+    return {
+      kind,
+      name,
+      closed: Boolean(value.closed),
+      minPoints,
+      maxPoints,
+      unit: optionalString3(value.unit),
+      points: value.points.map((point, index) => parsePathPoint(point, `${label}.points[${index}]`))
+    };
+  }
+  if (kind === "spline2d") {
+    const minPoints = requireInteger(value.minPoints, `${label}.minPoints`);
+    const maxPoints = requireInteger(value.maxPoints, `${label}.maxPoints`);
+    if (minPoints < 0 || maxPoints < minPoints) throw new Error(`Invalid manual edits ${label} point range`);
+    if (!Array.isArray(value.points)) throw new Error(`Invalid manual edits ${label}.points`);
+    const degree = requireInteger(value.degree, `${label}.degree`);
+    return {
+      kind,
+      name,
+      closed: Boolean(value.closed),
+      degree,
+      minPoints,
+      maxPoints,
+      unit: optionalString3(value.unit),
+      points: value.points.map((point, index) => parseSplinePoint(point, `${label}.points[${index}]`))
+    };
+  }
+  if (kind === "placement2d") {
+    if (!Array.isArray(value.zones)) throw new Error(`Invalid manual edits ${label}.zones`);
+    if (!Array.isArray(value.items)) throw new Error(`Invalid manual edits ${label}.items`);
+    return {
+      kind,
+      name,
+      frame: parsePlacementFrame(value.frame, `${label}.frame`),
+      zones: value.zones.map((zone, index) => parsePlacementZone(zone, `${label}.zones[${index}]`)),
+      rules: parsePlacementRules(value.rules, `${label}.rules`),
+      unit: optionalString3(value.unit),
+      items: value.items.map((item, index) => parsePlacementItem(item, `${label}.items[${index}]`))
+    };
+  }
+  throw new Error(`Invalid manual edits ${label}.kind`);
+}
+function parseManualParams(value) {
+  if (!Array.isArray(value)) throw new Error("Invalid manual edits manualParams");
+  return value.map((manualParam, index) => parseManualParam(manualParam, `manualParams[${index}]`));
+}
+function parseManualParamEditsDraft(value) {
+  if (!isRecord2(value)) throw new Error("Invalid manual edits draft");
+  if (value.kind !== MANUAL_PARAM_EDITS_DRAFT_KIND) throw new Error("Invalid manual edits draft kind");
+  return {
+    kind: MANUAL_PARAM_EDITS_DRAFT_KIND,
+    filePath: parseFilePath(value.filePath),
+    overrides: parseOverrides(value.overrides ?? {}),
+    manualParams: parseManualParams(value.manualParams)
+  };
+}
+function parseManualParamEditsPayload(value) {
+  if (!isRecord2(value)) throw new Error("Invalid manual edits payload");
+  if (value.kind !== MANUAL_PARAM_EDITS_KIND) throw new Error("Invalid manual edits kind");
+  const revision = requireInteger(value.revision, "revision");
+  if (revision < 1) throw new Error("Invalid manual edits revision");
+  return {
+    kind: MANUAL_PARAM_EDITS_KIND,
+    filePath: parseFilePath(value.filePath),
+    revision,
+    submittedAt: requireString4(value.submittedAt, "submittedAt"),
+    overrides: parseOverrides(value.overrides ?? {}),
+    manualParams: parseManualParams(value.manualParams)
+  };
+}
+function createSubmittedManualParamEdits(draftValue, previousRevision, submittedAt = (/* @__PURE__ */ new Date()).toISOString()) {
+  const draft = parseManualParamEditsDraft(draftValue);
+  return {
+    kind: MANUAL_PARAM_EDITS_KIND,
+    filePath: draft.filePath,
+    revision: Math.max(0, previousRevision ?? 0) + 1,
+    submittedAt,
+    overrides: draft.overrides,
+    manualParams: draft.manualParams
+  };
+}
+function formatManualParamEditsText(payload, source) {
+  const lines = [
+    `Manual parameter edits for ${payload.filePath}`,
+    `Revision: ${payload.revision}${source ? ` (${source})` : ""}`,
+    `Submitted: ${payload.submittedAt}`,
+    `Changed override keys: ${Object.keys(payload.overrides).length}`,
+    `Manual controls: ${payload.manualParams.length}`,
+    "",
+    "Apply these by updating the matching Param.path2d(...), Param.spline2d(...), and Param.placement2d(...) defaults in source.",
+    "Use `--format json` for exact point, G-continuity, footprint, and zone data."
+  ];
+  if (payload.manualParams.length > 0) {
+    lines.push("");
+    for (const edit of payload.manualParams) {
+      if (edit.kind === "path2d") {
+        lines.push(
+          `- path2d ${edit.name}: ${edit.points.length} ${edit.closed ? "outline" : "centerline"} point${edit.points.length === 1 ? "" : "s"}`
+        );
+      } else if (edit.kind === "spline2d") {
+        const gCounts = edit.points.reduce(
+          (counts, point) => ({ ...counts, [point.g]: counts[point.g] + 1 }),
+          { G0: 0, G1: 0, G2: 0 }
+        );
+        lines.push(
+          `- spline2d ${edit.name}: ${edit.points.length} point${edit.points.length === 1 ? "" : "s"}, degree ${edit.degree}, G0 ${gCounts.G0}, G1 ${gCounts.G1}, G2 ${gCounts.G2}`
+        );
+      } else {
+        const zoneCount = edit.zones.length;
+        lines.push(
+          `- placement2d ${edit.name}: ${edit.items.length} item${edit.items.length === 1 ? "" : "s"}, ${zoneCount} zone${zoneCount === 1 ? "" : "s"}, collisions ${edit.rules.collisions}`
+        );
+      }
+    }
+  }
+  return lines.join("\n");
+}
+
+// cli/manual-param-edits-storage.ts
+var MANUAL_PARAM_EDITS_ROOT = path3.join(".forgecad", "manual-param-edits", "files");
+function localManualParamEditsPath(projectRoot, filePath) {
+  const normalizedFilePath = filePath.split("\\").join("/");
+  const contextRoot = path3.resolve(projectRoot, MANUAL_PARAM_EDITS_ROOT);
+  const resolved = path3.resolve(contextRoot, `${normalizedFilePath}.json`);
+  if (!resolved.startsWith(contextRoot + path3.sep) && resolved !== contextRoot) {
+    throw new Error(`Invalid manual edits file path: ${filePath}`);
+  }
+  return resolved;
+}
+function readLocalManualParamEdits(projectRoot, filePath) {
+  const contextPath = localManualParamEditsPath(projectRoot, filePath);
+  if (!fs2.existsSync(contextPath)) return null;
+  return parseManualParamEditsPayload(JSON.parse(fs2.readFileSync(contextPath, "utf-8")));
+}
+function writeSubmittedLocalManualParamEdits(projectRoot, draft) {
+  const draftFilePath = typeof draft === "object" && draft !== null && "filePath" in draft ? String(draft.filePath) : "";
+  const existing = draftFilePath ? readLocalManualParamEdits(projectRoot, draftFilePath) : null;
+  const context = createSubmittedManualParamEdits(draft, existing?.revision ?? null);
+  const contextPath = localManualParamEditsPath(projectRoot, context.filePath);
+  fs2.mkdirSync(path3.dirname(contextPath), { recursive: true });
+  const tempPath = `${contextPath}.${process.pid}.${Date.now()}.tmp`;
+  fs2.writeFileSync(tempPath, JSON.stringify(context, null, 2) + "\n", "utf-8");
+  fs2.renameSync(tempPath, contextPath);
+  return context;
+}
+
 // cli/forge-studio-server.ts
 var PROJECT_FILE_EXTS = [
   ".forge.js",
@@ -33583,14 +33888,14 @@ var MIME = {
   ".md": "text/plain; charset=utf-8"
 };
 function slugFromDir(dir) {
-  const name = path3.basename(dir);
+  const name = path4.basename(dir);
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-+|-+$/g, "").slice(0, 64) || "project";
 }
 function buildProjectRegistry(dirs) {
   const projects = [];
   const usedSlugs = /* @__PURE__ */ new Set();
   for (const dir of dirs) {
-    const absDir = path3.resolve(dir);
+    const absDir = path4.resolve(dir);
     let slug2 = slugFromDir(absDir);
     if (usedSlugs.has(slug2)) {
       let i = 2;
@@ -33601,7 +33906,7 @@ function buildProjectRegistry(dirs) {
     projects.push({
       id: slug2,
       // Stable, URL-safe ID
-      name: path3.basename(absDir),
+      name: path4.basename(absDir),
       slug: slug2,
       dir: absDir
     });
@@ -33640,19 +33945,19 @@ function readBinaryBody(req) {
   });
 }
 function scanProjectFiles(projectDir) {
-  const abs = path3.resolve(projectDir);
+  const abs = path4.resolve(projectDir);
   const files = {};
   const folderSet = /* @__PURE__ */ new Set();
   function scan(dir, prefix) {
-    for (const item of fs2.readdirSync(dir, { withFileTypes: true })) {
+    for (const item of fs3.readdirSync(dir, { withFileTypes: true })) {
       if (item.name.startsWith(".")) continue;
       const rel = prefix ? `${prefix}/${item.name}` : item.name;
       if (item.isDirectory()) {
         if (shouldSkipProjectDirectory2(item.name)) continue;
         folderSet.add(rel);
-        scan(path3.join(dir, item.name), rel);
+        scan(path4.join(dir, item.name), rel);
       } else if (item.isFile() && !isLocalProjectManifestPath(rel) && isProjectFile(item.name)) {
-        files[rel] = fs2.readFileSync(path3.join(dir, item.name), "utf-8");
+        files[rel] = fs3.readFileSync(path4.join(dir, item.name), "utf-8");
       } else if (item.isFile() && isBinaryProjectFile(item.name)) {
         files[rel] = "";
       }
@@ -33665,17 +33970,17 @@ function scanProjectFiles(projectDir) {
   return { files, folders: [...folderSet] };
 }
 function scanProjectFileListing(projectDir) {
-  const abs = path3.resolve(projectDir);
+  const abs = path4.resolve(projectDir);
   const files = [];
   const folders = [];
   function scan(dir, prefix) {
-    for (const item of fs2.readdirSync(dir, { withFileTypes: true })) {
+    for (const item of fs3.readdirSync(dir, { withFileTypes: true })) {
       if (item.name.startsWith(".")) continue;
       const rel = prefix ? `${prefix}/${item.name}` : item.name;
       if (item.isDirectory()) {
         if (shouldSkipProjectDirectory2(item.name)) continue;
         folders.push(rel);
-        scan(path3.join(dir, item.name), rel);
+        scan(path4.join(dir, item.name), rel);
       } else if (item.isFile() && !isLocalProjectManifestPath(rel) && (isProjectFile(item.name) || isBinaryProjectFile(item.name))) {
         files.push(rel);
       }
@@ -33690,11 +33995,11 @@ function scanProjectFileListing(projectDir) {
 function resolveProjectFile(projectDir, filename, opts = {}) {
   if (!projectDir) throw new Error("No project directory");
   if (!filename) throw new Error("Invalid file path");
-  const abs = path3.resolve(projectDir);
-  const filePath = path3.isAbsolute(filename) ? path3.resolve(filename) : path3.resolve(abs, filename);
+  const abs = path4.resolve(projectDir);
+  const filePath = path4.isAbsolute(filename) ? path4.resolve(filename) : path4.resolve(abs, filename);
   if (!isProjectFile(filePath) && !(opts.allowBinary && isBinaryProjectFile(filePath))) throw new Error("Invalid file type");
-  const rel = path3.relative(abs, filePath);
-  if (rel.startsWith("..") || path3.isAbsolute(rel)) {
+  const rel = path4.relative(abs, filePath);
+  if (rel.startsWith("..") || path4.isAbsolute(rel)) {
     throw new Error(`Path "${filename}" is outside the project root`);
   }
   if (isLocalProjectManifestPath(rel.replace(/\\/g, "/"))) throw new Error("Project manifest is not editable");
@@ -33703,31 +34008,31 @@ function resolveProjectFile(projectDir, filename, opts = {}) {
 function resolveProjectDirectory(projectDir, dirPath) {
   if (!projectDir) throw new Error("No project directory");
   if (!dirPath) throw new Error("Invalid directory path");
-  const abs = path3.resolve(projectDir);
-  const resolved = path3.resolve(abs, dirPath);
-  const rel = path3.relative(abs, resolved);
-  if (rel.startsWith("..") || path3.isAbsolute(rel)) {
+  const abs = path4.resolve(projectDir);
+  const resolved = path4.resolve(abs, dirPath);
+  const rel = path4.relative(abs, resolved);
+  if (rel.startsWith("..") || path4.isAbsolute(rel)) {
     throw new Error(`Path "${dirPath}" is outside the project root`);
   }
   return { dirPath: resolved, dirname: rel.replace(/\\/g, "/") };
 }
 function serveStatic(distDir, req, res) {
-  const absDistDir = path3.resolve(distDir);
+  const absDistDir = path4.resolve(distDir);
   const urlPath = decodeURIComponent((req.url ?? "/").split("?")[0]);
-  let filePath = path3.resolve(absDistDir, urlPath === "/" ? "index.html" : "." + urlPath);
-  if (!filePath.startsWith(absDistDir + path3.sep) && filePath !== absDistDir) {
+  let filePath = path4.resolve(absDistDir, urlPath === "/" ? "index.html" : "." + urlPath);
+  if (!filePath.startsWith(absDistDir + path4.sep) && filePath !== absDistDir) {
     res.statusCode = 403;
     res.end("Forbidden");
     return true;
   }
-  if (!fs2.existsSync(filePath) || !fs2.statSync(filePath).isFile()) {
-    filePath = path3.join(absDistDir, "index.html");
+  if (!fs3.existsSync(filePath) || !fs3.statSync(filePath).isFile()) {
+    filePath = path4.join(absDistDir, "index.html");
   }
-  if (!fs2.existsSync(filePath)) return false;
-  const ext = path3.extname(filePath).toLowerCase();
+  if (!fs3.existsSync(filePath)) return false;
+  const ext = path4.extname(filePath).toLowerCase();
   const mime = MIME[ext] ?? "application/octet-stream";
   const isText = mime.includes("charset");
-  const content = fs2.readFileSync(filePath, isText ? "utf-8" : null);
+  const content = fs3.readFileSync(filePath, isText ? "utf-8" : null);
   res.statusCode = 200;
   res.setHeader("Content-Type", mime);
   res.setHeader("Cache-Control", urlPath.startsWith("/assets/") ? "max-age=31536000,immutable" : "no-cache");
@@ -33845,18 +34150,18 @@ data: ${JSON.stringify(data)}
     });
   }
   for (const proj of projects) {
-    const abs = path3.resolve(proj.dir);
+    const abs = path4.resolve(proj.dir);
     const watcher = chokidar.watch(abs, {
       ignoreInitial: true,
-      ignored: (candidate) => path3.relative(abs, candidate).split(/[\\/]/).some(shouldSkipProjectDirectory2)
+      ignored: (candidate) => path4.relative(abs, candidate).split(/[\\/]/).some(shouldSkipProjectDirectory2)
     });
     watcherReadyPromises.push(waitForWatcherReady(watcher));
     watcher.on("add", (f2) => {
-      const rel = path3.relative(abs, f2).replace(/\\/g, "/");
+      const rel = path4.relative(abs, f2).replace(/\\/g, "/");
       if (isLocalProjectManifestPath(rel)) return;
       if (isProjectFile(f2)) {
         try {
-          broadcastToProject(proj.id, "change", { filename: rel, content: fs2.readFileSync(f2, "utf-8") });
+          broadcastToProject(proj.id, "change", { filename: rel, content: fs3.readFileSync(f2, "utf-8") });
         } catch {
         }
       } else if (isBinaryProjectFile(f2)) {
@@ -33864,11 +34169,11 @@ data: ${JSON.stringify(data)}
       }
     });
     watcher.on("change", (f2) => {
-      const rel = path3.relative(abs, f2).replace(/\\/g, "/");
+      const rel = path4.relative(abs, f2).replace(/\\/g, "/");
       if (isLocalProjectManifestPath(rel)) return;
       if (isProjectFile(f2)) {
         try {
-          broadcastToProject(proj.id, "change", { filename: rel, content: fs2.readFileSync(f2, "utf-8") });
+          broadcastToProject(proj.id, "change", { filename: rel, content: fs3.readFileSync(f2, "utf-8") });
         } catch {
         }
       } else if (isBinaryProjectFile(f2)) {
@@ -33876,7 +34181,7 @@ data: ${JSON.stringify(data)}
       }
     });
     watcher.on("unlink", (f2) => {
-      const rel = path3.relative(abs, f2).replace(/\\/g, "/");
+      const rel = path4.relative(abs, f2).replace(/\\/g, "/");
       if (isLocalProjectManifestPath(rel)) return;
       if (!isProjectFile(f2) && !isBinaryProjectFile(f2)) return;
       broadcastToProject(proj.id, "delete", { filename: rel });
@@ -34035,11 +34340,11 @@ data: ${JSON.stringify(data)}
         }
         try {
           const resolved = resolveProjectFile(proj.dir, filename);
-          if (!fs2.existsSync(resolved.filePath)) {
+          if (!fs3.existsSync(resolved.filePath)) {
             sendJson(res, 404, { error: `File not found: ${filename}` });
             return;
           }
-          const content = fs2.readFileSync(resolved.filePath, "utf-8");
+          const content = fs3.readFileSync(resolved.filePath, "utf-8");
           sendJson(res, 200, { filename: resolved.filename, content });
         } catch (e) {
           sendJson(res, 400, { error: e.message });
@@ -34063,7 +34368,7 @@ data: ${JSON.stringify(data)}
         }
         try {
           const resolved = resolveProjectFile(proj.dir, entry);
-          if (!fs2.existsSync(resolved.filePath)) {
+          if (!fs3.existsSync(resolved.filePath)) {
             sendJson(res, 404, { error: `File not found: ${entry}` });
             return;
           }
@@ -34123,6 +34428,54 @@ data: ${JSON.stringify(data)}
         return;
       }
     }
+    {
+      const m = matchProjectRoute(url2, method, "GET", "/manual-param-edits");
+      if (m) {
+        const proj = lookupProject(m.projectId);
+        if (!proj) {
+          sendJson(res, 404, { error: "Project not found" });
+          return;
+        }
+        const params = new URLSearchParams(m.query);
+        const filePath = params.get("file");
+        if (!filePath) {
+          sendJson(res, 400, { error: "Missing file parameter" });
+          return;
+        }
+        try {
+          const resolved = resolveProjectFile(proj.dir, filePath);
+          const context = readLocalManualParamEdits(proj.dir, resolved.filename);
+          if (!context) {
+            sendJson(res, 404, { error: `No submitted manual edits for ${resolved.filename}` });
+            return;
+          }
+          sendJson(res, 200, { context });
+        } catch (e) {
+          sendJson(res, 400, { error: e.message });
+        }
+        return;
+      }
+    }
+    {
+      const m = matchProjectRoute(url2, method, "POST", "/manual-param-edits");
+      if (m) {
+        const proj = lookupProject(m.projectId);
+        if (!proj) {
+          sendJson(res, 404, { error: "Project not found" });
+          return;
+        }
+        readJsonBody(req).then((body) => {
+          if (!body || typeof body.filePath !== "string") {
+            sendJson(res, 400, { error: "Invalid manual edits draft" });
+            return;
+          }
+          const resolved = resolveProjectFile(proj.dir, body.filePath);
+          const context = writeSubmittedLocalManualParamEdits(proj.dir, { ...body, filePath: resolved.filename });
+          sendJson(res, 200, { context });
+        }).catch((e) => sendJson(res, 400, { error: e.message }));
+        return;
+      }
+    }
     {
       const m = method === "GET" ? matchSSERoute(url2, "/watch") : null;
       if (m) {
@@ -34171,8 +34524,8 @@ data: ${JSON.stringify(data)}
             return;
           }
           const resolved = resolveProjectFile(proj.dir, filename);
-          fs2.mkdirSync(path3.dirname(resolved.filePath), { recursive: true });
-          fs2.writeFileSync(resolved.filePath, content, "utf-8");
+          fs3.mkdirSync(path4.dirname(resolved.filePath), { recursive: true });
+          fs3.writeFileSync(resolved.filePath, content, "utf-8");
           sendJson(res, 200, { success: true });
         }).catch((e) => sendJson(res, 500, { error: e.message }));
         return;
@@ -34198,8 +34551,8 @@ data: ${JSON.stringify(data)}
             sendJson(res, 400, { error: `Not a binary import file: ${filename}` });
             return;
           }
-          fs2.mkdirSync(path3.dirname(resolved.filePath), { recursive: true });
-          fs2.writeFileSync(resolved.filePath, body);
+          fs3.mkdirSync(path4.dirname(resolved.filePath), { recursive: true });
+          fs3.writeFileSync(resolved.filePath, body);
           sendJson(res, 200, { success: true });
         }).catch((e) => sendJson(res, 500, { error: e.message }));
         return;
@@ -34220,8 +34573,8 @@ data: ${JSON.stringify(data)}
             return;
           }
           const resolved = resolveProjectFile(proj.dir, filename, { allowBinary: true });
-          if (fs2.existsSync(resolved.filePath)) {
-            fs2.unlinkSync(resolved.filePath);
+          if (fs3.existsSync(resolved.filePath)) {
+            fs3.unlinkSync(resolved.filePath);
           }
           sendJson(res, 200, { success: true });
         }).catch((e) => sendJson(res, 500, { error: e.message }));
@@ -34242,12 +34595,12 @@ data: ${JSON.stringify(data)}
             sendJson(res, 400, { error: "Invalid request" });
             return;
           }
-          const absDir = path3.resolve(proj.dir, dirPath);
-          if (!absDir.startsWith(proj.dir + path3.sep) && absDir !== proj.dir) {
+          const absDir = path4.resolve(proj.dir, dirPath);
+          if (!absDir.startsWith(proj.dir + path4.sep) && absDir !== proj.dir) {
             sendJson(res, 403, { error: "Path outside project root" });
             return;
           }
-          fs2.mkdirSync(absDir, { recursive: true });
+          fs3.mkdirSync(absDir, { recursive: true });
           sendJson(res, 200, { success: true });
         }).catch((e) => sendJson(res, 500, { error: e.message }));
         return;
@@ -34278,15 +34631,15 @@ data: ${JSON.stringify(data)}
             sendJson(res, 400, { error: "Cannot delete project root" });
             return;
           }
-          if (!fs2.existsSync(resolved.dirPath)) {
+          if (!fs3.existsSync(resolved.dirPath)) {
             sendJson(res, 200, { success: true });
             return;
           }
-          if (!fs2.statSync(resolved.dirPath).isDirectory()) {
+          if (!fs3.statSync(resolved.dirPath).isDirectory()) {
             sendJson(res, 400, { error: "Path is not a directory" });
             return;
           }
-          fs2.rmSync(resolved.dirPath, { recursive: true, force: true });
+          fs3.rmSync(resolved.dirPath, { recursive: true, force: true });
           sendJson(res, 200, { success: true });
         }).catch((e) => sendJson(res, 500, { error: e.message }));
         return;
@@ -34308,16 +34661,16 @@ data: ${JSON.stringify(data)}
           }
           const fromResolved = resolveProjectFile(proj.dir, from, { allowBinary: true });
           const toResolved = resolveProjectFile(proj.dir, to, { allowBinary: true });
-          if (!fs2.existsSync(fromResolved.filePath)) {
+          if (!fs3.existsSync(fromResolved.filePath)) {
             sendJson(res, 404, { error: `File not found: ${from}` });
             return;
           }
-          if (fs2.existsSync(toResolved.filePath)) {
+          if (fs3.existsSync(toResolved.filePath)) {
             sendJson(res, 409, { error: `Destination already exists: ${to}` });
             return;
           }
-          fs2.mkdirSync(path3.dirname(toResolved.filePath), { recursive: true });
-          fs2.renameSync(fromResolved.filePath, toResolved.filePath);
+          fs3.mkdirSync(path4.dirname(toResolved.filePath), { recursive: true });
+          fs3.renameSync(fromResolved.filePath, toResolved.filePath);
           sendJson(res, 200, { success: true });
         }).catch((e) => sendJson(res, 500, { error: e.message }));
         return;
@@ -34337,10 +34690,10 @@ data: ${JSON.stringify(data)}
           sendJson(res, 400, { error: "Missing path parameter" });
           return;
         }
-        const absProject = path3.resolve(proj.dir);
-        const filePath = path3.resolve(absProject, filename);
-        const rel = path3.relative(absProject, filePath);
-        if (rel.startsWith("..") || path3.isAbsolute(rel)) {
+        const absProject = path4.resolve(proj.dir);
+        const filePath = path4.resolve(absProject, filename);
+        const rel = path4.relative(absProject, filePath);
+        if (rel.startsWith("..") || path4.isAbsolute(rel)) {
           sendJson(res, 403, { error: "Path outside project root" });
           return;
         }
@@ -34348,11 +34701,11 @@ data: ${JSON.stringify(data)}
           sendJson(res, 400, { error: `Not a binary import file: ${filename}` });
           return;
         }
-        if (!fs2.existsSync(filePath)) {
+        if (!fs3.existsSync(filePath)) {
           sendJson(res, 404, { error: `File not found: ${filename}` });
           return;
         }
-        const data = fs2.readFileSync(filePath);
+        const data = fs3.readFileSync(filePath);
         res.writeHead(200, { "Content-Type": "application/octet-stream" });
         res.end(data);
         return;
@@ -34369,6 +34722,16 @@ data: ${JSON.stringify(data)}
         sendJson(res, 200, { linked: false });
         return;
       }
+      if (!hasRemoteProject(manifest)) {
+        sendJson(res, 200, {
+          linked: false,
+          initialized: true,
+          slug: manifest.slug,
+          server: manifest.server,
+          message: "Run `forgecad project push` to create the hosted project."
+        });
+        return;
+      }
       const auth = readStoredAuth();
       if (!auth) {
         sendJson(res, 200, { linked: true, authenticated: false, slug: manifest.slug, server: manifest.server });
@@ -34410,6 +34773,10 @@ data: ${JSON.stringify(data)}
         sendJson(res, 400, { error: "Not linked to a remote project" });
         return;
       }
+      if (!hasRemoteProject(manifest)) {
+        sendJson(res, 400, { error: "Project has not been pushed yet. Run `forgecad project push` first." });
+        return;
+      }
       const auth = readStoredAuth();
       if (!auth) {
         sendJson(res, 401, { error: "Not authenticated. Run `forgecad login` first." });
@@ -34580,7 +34947,7 @@ async function runStudioCli(argv = process.argv.slice(2)) {
 // cli/forge-context.ts
 import { existsSync as existsSync22 } from "fs";
 import { mkdir as mkdir4, rename as rename2, rm as rm2, writeFile as writeFile8 } from "fs/promises";
-import path4 from "path";
+import path5 from "path";
 function usage21(command) {
   if (command === "render") return "Usage: forgecad context render <model.forge.js> [--out <dir>] [--force] [--size <px>]";
   return `Usage: forgecad context ${command} <model.forge.js> [--format text|json]`;
@@ -34649,16 +35016,16 @@ ${usage21("render")}`);
   return { filePath, outDir, force, size };
 }
 function resolveProjectFile2(filePath) {
-  const absFilePath = path4.resolve(filePath);
+  const absFilePath = path5.resolve(filePath);
   if (!existsSync22(absFilePath)) throw new Error(`File not found: ${filePath}`);
   const projectRoot = findProjectRoot(absFilePath);
-  const fileName = path4.relative(projectRoot, absFilePath).replace(/\\/g, "/");
-  if (fileName.startsWith("..") || path4.isAbsolute(fileName)) throw new Error(`File is outside project root: ${filePath}`);
+  const fileName = path5.relative(projectRoot, absFilePath).replace(/\\/g, "/");
+  if (fileName.startsWith("..") || path5.isAbsolute(fileName)) throw new Error(`File is outside project root: ${filePath}`);
   return { projectRoot, fileName };
 }
 async function readRemoteAgentContext(projectRoot, fileName) {
   const manifest = readManifest(projectRoot);
-  if (!manifest) return null;
+  if (!manifest || !hasRemoteProject(manifest)) return null;
   const res = await authenticatedFetch(`/api/projects/${manifest.projectId}/agent-context?file=${encodeURIComponent(fileName)}`);
   if (res.status === 404) return null;
   if (!res.ok) {
@@ -34707,9 +35074,9 @@ function outputContextStem(fileName) {
   return fileName.replace(/\.js$/i, "").split("\\").join("/");
 }
 async function allocateBundleDir(projectRoot, fileName, revision, outDir, force) {
-  const requested = outDir ? path4.resolve(outDir) : (() => {
+  const requested = outDir ? path5.resolve(outDir) : (() => {
     const { dateDir, timeStem } = timestampParts();
-    return path4.resolve(projectRoot, "outputs", "context", outputContextStem(fileName), dateDir, `${timeStem}-rev${revision}`);
+    return path5.resolve(projectRoot, "outputs", "context", outputContextStem(fileName), dateDir, `${timeStem}-rev${revision}`);
   })();
   if (force) {
     await rm2(requested, { recursive: true, force: true });
@@ -34727,7 +35094,7 @@ async function allocateBundleDir(projectRoot, fileName, revision, outDir, force)
   throw new Error(`Could not allocate a non-colliding context bundle directory near ${requested}`);
 }
 function bundleRelativePath(projectRoot, bundleDir) {
-  return path4.relative(projectRoot, bundleDir).split(path4.sep).join("/");
+  return path5.relative(projectRoot, bundleDir).split(path5.sep).join("/");
 }
 function renderRequirePath(fileName) {
   return `./${fileName.split("\\").join("/")}`;
@@ -34789,13 +35156,13 @@ return rendered;
 `;
 }
 async function writeContextRenderWrapper(projectRoot, fileName, context) {
-  const wrapperPath = path4.join(projectRoot, `.forgecad-context-render-${process.pid}-${Date.now()}.forge.js`);
+  const wrapperPath = path5.join(projectRoot, `.forgecad-context-render-${process.pid}-${Date.now()}.forge.js`);
   await writeFile8(wrapperPath, buildContextRenderWrapper(fileName, context), "utf-8");
   return wrapperPath;
 }
 async function renderContextViews(wrapperPath, viewsDir, size) {
   await mkdir4(viewsDir, { recursive: true });
-  const outputBase = path4.join(viewsDir, "view.png");
+  const outputBase = path5.join(viewsDir, "view.png");
   await runRenderCli([
     wrapperPath,
     outputBase,
@@ -34812,11 +35179,11 @@ async function renderContextViews(wrapperPath, viewsDir, size) {
   ]);
   const viewNames = ["iso", "front", "right", "top"];
   for (const view of viewNames) {
-    const produced = path4.join(viewsDir, `view_${view}.png`);
-    const target = path4.join(viewsDir, `${view}.png`);
+    const produced = path5.join(viewsDir, `view_${view}.png`);
+    const target = path5.join(viewsDir, `${view}.png`);
     if (existsSync22(produced)) await rename2(produced, target);
   }
-  return viewNames.filter((view) => existsSync22(path4.join(viewsDir, `${view}.png`)));
+  return viewNames.filter((view) => existsSync22(path5.join(viewsDir, `${view}.png`)));
 }
 function briefMarkdown(context, views) {
   const lines = [
@@ -34845,11 +35212,11 @@ function briefMarkdown(context, views) {
 async function writeContextBundle(projectRoot, bundleDir, context, views) {
   const latestBundle = bundleRelativePath(projectRoot, bundleDir);
   const updatedContext = updateLocalAgentContextLatestBundle(projectRoot, context.filePath, latestBundle);
-  await writeFile8(path4.join(bundleDir, "context.json"), `${JSON.stringify(updatedContext, null, 2)}
+  await writeFile8(path5.join(bundleDir, "context.json"), `${JSON.stringify(updatedContext, null, 2)}
 `, "utf-8");
-  await writeFile8(path4.join(bundleDir, "brief.md"), briefMarkdown(updatedContext, views), "utf-8");
+  await writeFile8(path5.join(bundleDir, "brief.md"), briefMarkdown(updatedContext, views), "utf-8");
   await writeFile8(
-    path4.join(bundleDir, "manifest.json"),
+    path5.join(bundleDir, "manifest.json"),
     `${JSON.stringify(
       {
         kind: "forgecad.agentContextBundle.v1",
@@ -34926,7 +35293,7 @@ async function runContextRenderCli(args = process.argv.slice(2)) {
       throw new Error("context render currently requires a local submitted context sidecar.");
     }
     const bundleDir = await allocateBundleDir(loaded.projectRoot, loaded.filePath, loaded.context.revision, parsed.outDir, parsed.force);
-    const viewsDir = path4.join(bundleDir, "views");
+    const viewsDir = path5.join(bundleDir, "views");
     wrapperPath = await writeContextRenderWrapper(loaded.projectRoot, loaded.filePath, loaded.context);
     const views = await renderContextViews(wrapperPath, viewsDir, parsed.size);
     if (views.length === 0) throw new Error("Context render did not produce any view PNGs.");
@@ -34936,7 +35303,7 @@ async function runContextRenderCli(args = process.argv.slice(2)) {
     console.log(`  File:     ${updatedContext.filePath}`);
     console.log(`  Revision: ${updatedContext.revision}`);
     console.log(`  Bundle:   ${bundleRelativePath(loaded.projectRoot, bundleDir)}`);
-    console.log(`  Brief:    ${path4.join(bundleRelativePath(loaded.projectRoot, bundleDir), "brief.md")}`);
+    console.log(`  Brief:    ${path5.join(bundleRelativePath(loaded.projectRoot, bundleDir), "brief.md")}`);
   } catch (error) {
     console.error(error instanceof Error ? error.message : String(error));
     process.exit(1);
@@ -34945,17 +35312,139 @@ async function runContextRenderCli(args = process.argv.slice(2)) {
   }
 }
 
+// cli/forge-manual-edits.ts
+import { existsSync as existsSync23 } from "fs";
+import path6 from "path";
+function usage22(command) {
+  return `Usage: forgecad manual-edits ${command} <model.forge.js> [--format text|json]`;
+}
+function parseArgs19(command, args) {
+  let filePath;
+  let format = "text";
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--format") {
+      const value = args[++i];
+      if (value !== "text" && value !== "json") throw new Error(usage22(command));
+      format = value;
+    } else if (arg.startsWith("--format=")) {
+      const value = arg.slice("--format=".length);
+      if (value !== "text" && value !== "json") throw new Error(usage22(command));
+      format = value;
+    } else if (arg.startsWith("-")) {
+      throw new Error(`Unknown option: ${arg}
+${usage22(command)}`);
+    } else if (!filePath) {
+      filePath = arg;
+    } else {
+      throw new Error(`Unexpected argument: ${arg}
+${usage22(command)}`);
+    }
+  }
+  if (!filePath) throw new Error(usage22(command));
+  return { filePath, format };
+}
+function resolveProjectFile3(filePath) {
+  const absFilePath = path6.resolve(filePath);
+  if (!existsSync23(absFilePath)) throw new Error(`File not found: ${filePath}`);
+  const projectRoot = findProjectRoot(absFilePath);
+  const fileName = path6.relative(projectRoot, absFilePath).replace(/\\/g, "/");
+  if (fileName.startsWith("..") || path6.isAbsolute(fileName)) throw new Error(`File is outside project root: ${filePath}`);
+  return { projectRoot, fileName };
+}
+async function readRemoteManualParamEdits(projectRoot, fileName) {
+  const manifest = readManifest(projectRoot);
+  if (!manifest || !hasRemoteProject(manifest)) return null;
+  const res = await authenticatedFetch(`/api/projects/${manifest.projectId}/manual-param-edits?file=${encodeURIComponent(fileName)}`);
+  if (res.status === 404) return null;
+  if (!res.ok) {
+    const body = await res.json().catch(() => ({}));
+    throw new Error(body.error ?? `Failed to read remote manual edits (${res.status})`);
+  }
+  const data = await res.json();
+  return parseManualParamEditsPayload(data.context);
+}
+async function loadManualParamEdits(filePath) {
+  const { projectRoot, fileName } = resolveProjectFile3(filePath);
+  const local = readLocalManualParamEdits(projectRoot, fileName);
+  if (local) return { projectRoot, filePath: fileName, context: local, source: "local" };
+  try {
+    const remote = await readRemoteManualParamEdits(projectRoot, fileName);
+    if (remote) return { projectRoot, filePath: fileName, context: remote, source: "remote" };
+    return { projectRoot, filePath: fileName, context: null };
+  } catch (error) {
+    return {
+      projectRoot,
+      filePath: fileName,
+      context: null,
+      remoteError: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function statusForLoaded2(loaded) {
+  return {
+    filePath: loaded.filePath,
+    exists: loaded.context !== null,
+    revision: loaded.context?.revision ?? null,
+    submittedAt: loaded.context?.submittedAt ?? null,
+    manualParamCount: loaded.context?.manualParams.length ?? 0,
+    overrideCount: loaded.context ? Object.keys(loaded.context.overrides).length : 0,
+    source: loaded.source
+  };
+}
+async function runManualEditsGetCli(args = process.argv.slice(2)) {
+  try {
+    const parsed = parseArgs19("get", args);
+    const loaded = await loadManualParamEdits(parsed.filePath);
+    if (!loaded.context) {
+      console.error(`No submitted manual edits for ${loaded.filePath}.`);
+      if (loaded.remoteError) console.error(`Remote lookup failed: ${loaded.remoteError}`);
+      process.exit(1);
+    }
+    if (parsed.format === "json") {
+      console.log(JSON.stringify({ context: loaded.context, source: loaded.source }, null, 2));
+      return;
+    }
+    console.log(formatManualParamEditsText(loaded.context, loaded.source));
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+async function runManualEditsStatusCli(args = process.argv.slice(2)) {
+  try {
+    const parsed = parseArgs19("status", args);
+    const loaded = await loadManualParamEdits(parsed.filePath);
+    const status = statusForLoaded2(loaded);
+    if (parsed.format === "json") {
+      console.log(JSON.stringify({ status, remoteError: loaded.remoteError }, null, 2));
+      return;
+    }
+    if (!loaded.context) {
+      console.log(`${loaded.filePath}: no submitted manual edits`);
+      if (loaded.remoteError) console.log(`remote lookup failed: ${loaded.remoteError}`);
+      return;
+    }
+    console.log(
+      `${loaded.filePath}: rev ${loaded.context.revision}, ${loaded.context.manualParams.length} manual control${loaded.context.manualParams.length === 1 ? "" : "s"}, ${Object.keys(loaded.context.overrides).length} changed override key${Object.keys(loaded.context.overrides).length === 1 ? "" : "s"}, submitted ${loaded.context.submittedAt}${loaded.source ? ` (${loaded.source})` : ""}`
+    );
+  } catch (error) {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  }
+}
+
 // cli/forge-svg.ts
 import { readFile as readFile5, writeFile as writeFile9 } from "fs/promises";
 import { basename as basename17, resolve as resolve42 } from "path";
-function usage22() {
+function usage23() {
   console.error("Usage: forgecad export svg <script.forge.js> [input ...] [--output path] [--param Key=Value]");
   process.exit(1);
 }
 function defaultSvgOutput(scriptPath) {
   return scriptPath.replace(/\.(forge|sketch)\.js$/, ".svg").replace(/\.js$/, ".svg");
 }
-function parseArgs19(argv) {
+function parseArgs20(argv) {
   const inputPaths = [];
   let outputPath;
   const paramOverrides = {};
@@ -34985,11 +35474,11 @@ function parseArgs19(argv) {
 async function runSvgCli(argv = process.argv.slice(2)) {
   let parsed;
   try {
-    parsed = parseArgs19(argv);
+    parsed = parseArgs20(argv);
     requireExistingInputPaths(parsed.inputPaths);
   } catch (error) {
     console.error(error instanceof Error ? error.message : String(error));
-    usage22();
+    usage23();
   }
   let failures = 0;
   for (const [index, scriptPath] of parsed.inputPaths.entries()) {
@@ -35446,7 +35935,7 @@ function buildUrdfRobotPackage(spec) {
 }
 
 // cli/forge-urdf.ts
-function parseArgs20(argv) {
+function parseArgs21(argv) {
   const inputPaths = [];
   let outputPath;
   const paramOverrides = {};
@@ -35498,7 +35987,7 @@ function resolveSimulationModel4(result, jointOverrides) {
   return collectSimulationModel(def, { state: jointOverrides });
 }
 async function runUrdfCli(argv = process.argv.slice(2)) {
-  const { inputPaths, outputPath, paramOverrides, jointOverrides } = parseArgs20(argv);
+  const { inputPaths, outputPath, paramOverrides, jointOverrides } = parseArgs21(argv);
   requireExistingInputPaths(inputPaths);
   let failures = 0;
   for (const [index, scriptPath] of inputPaths.entries()) {
@@ -36189,7 +36678,7 @@ ${jointResults.map((result) => result.text).join("\n\n")}
 }
 
 // cli/forge-usd.ts
-function parseArgs21(argv) {
+function parseArgs22(argv) {
   const inputPaths = [];
   let outputPath;
   const paramOverrides = {};
@@ -36239,7 +36728,7 @@ function resolveSimulationModel5(result, jointOverrides) {
   return collectSimulationModel(def, { state: jointOverrides });
 }
 async function runUsdCli(argv = process.argv.slice(2)) {
-  const { inputPaths, outputPath, paramOverrides, jointOverrides } = parseArgs21(argv);
+  const { inputPaths, outputPath, paramOverrides, jointOverrides } = parseArgs22(argv);
   requireExistingInputPaths(inputPaths);
   let failures = 0;
   for (const [index, scriptPath] of inputPaths.entries()) {
@@ -36357,7 +36846,7 @@ ${url}`);
 
 // cli/forge-publish.ts
 import { execSync as execSync4 } from "child_process";
-import { existsSync as existsSync23 } from "fs";
+import { existsSync as existsSync24 } from "fs";
 import { dirname as dirname12, relative as relative6, resolve as resolve45 } from "path";
 function findProjectRoot3(dir) {
   let current = resolve45(dir);
@@ -36434,7 +36923,7 @@ async function runPublishCli(args) {
     process.exit(1);
   }
   const resolved = resolve45(filePath);
-  if (!existsSync23(resolved)) {
+  if (!existsSync24(resolved)) {
     console.error(`File not found: ${filePath}`);
     process.exit(1);
   }
@@ -36446,6 +36935,11 @@ async function runPublishCli(args) {
     console.error("or `cd` into an existing project directory.");
     process.exit(1);
   }
+  if (!hasRemoteProject(project.manifest)) {
+    console.error("This project has not been created on the server yet.");
+    console.error("  Run `forgecad project push` first, then publish the file.");
+    process.exit(1);
+  }
   const relPath = relative6(project.root, resolved).replace(/\\/g, "/");
   if (!skipSync) {
     console.log(`Project "${project.manifest.slug}" \u2014 syncing...`);
@@ -36485,16 +36979,16 @@ async function runPublishCli(args) {
 
 // cli/doctor-dependencies.ts
 import { execFileSync as execFileSync3, execSync as execSync5 } from "child_process";
-import { existsSync as existsSync24 } from "fs";
+import { existsSync as existsSync25 } from "fs";
 function findExecutablePath2(staticCandidates, binCandidates) {
   for (const candidate of staticCandidates) {
-    if (existsSync24(candidate)) return candidate;
+    if (existsSync25(candidate)) return candidate;
   }
   for (const bin of binCandidates) {
     try {
       const cmd = process.platform === "win32" ? `where ${bin}` : `command -v ${bin}`;
       const found = execSync5(cmd, { stdio: ["ignore", "pipe", "ignore"] }).toString().trim().split(/\r?\n/)[0];
-      if (found && existsSync24(found)) return found;
+      if (found && existsSync25(found)) return found;
     } catch {
     }
   }
@@ -36505,13 +36999,13 @@ function findExecutableWithEnv(envName, staticCandidates, binCandidates) {
   if (!configured) return { path: findExecutablePath2(staticCandidates, binCandidates) };
   const looksLikePath2 = configured.includes("/") || configured.includes("\\");
   if (looksLikePath2) {
-    return existsSync24(configured) ? { path: configured } : { path: null, note: `${envName}=${configured} was not found` };
+    return existsSync25(configured) ? { path: configured } : { path: null, note: `${envName}=${configured} was not found` };
   }
   const found = findExecutablePath2([], [configured]);
   return found ? { path: found } : { path: null, note: `${envName}=${configured} was not found on PATH` };
 }
 function findChrome() {
-  if (process.env.CHROME_PATH && existsSync24(process.env.CHROME_PATH)) return process.env.CHROME_PATH;
+  if (process.env.CHROME_PATH && existsSync25(process.env.CHROME_PATH)) return process.env.CHROME_PATH;
   const candidatesByPlatform = {
     darwin: [
       "/Applications/Google Chrome.app/Contents/MacOS/Google Chrome",
@@ -36545,7 +37039,7 @@ function findChrome() {
   ]);
 }
 function findFfmpeg() {
-  if (process.env.FFMPEG_PATH && existsSync24(process.env.FFMPEG_PATH)) return process.env.FFMPEG_PATH;
+  if (process.env.FFMPEG_PATH && existsSync25(process.env.FFMPEG_PATH)) return process.env.FFMPEG_PATH;
   const candidatesByPlatform = {
     darwin: ["/opt/homebrew/bin/ffmpeg", "/usr/local/bin/ffmpeg"],
     linux: ["/usr/bin/ffmpeg", "/snap/bin/ffmpeg"],
@@ -36584,8 +37078,8 @@ function getVersion(executable, args) {
     return void 0;
   }
 }
-function okCheck(name, path5, version, usedBy) {
-  return { name, status: "ok", path: path5, version, usedBy };
+function okCheck(name, path7, version, usedBy) {
+  return { name, status: "ok", path: path7, version, usedBy };
 }
 function warnCheck(name, note, usedBy) {
   return { name, status: "warn", note, usedBy };
@@ -36724,12 +37218,12 @@ async function recordCliCommandEvent(input) {
 }
 
 // cli/forge-project.ts
-import { existsSync as existsSync26, mkdirSync as mkdirSync14, readFileSync as readFileSync30, writeFileSync as writeFileSync22 } from "fs";
-import { createInterface as createInterface2 } from "readline";
+import { existsSync as existsSync27, mkdirSync as mkdirSync14, readFileSync as readFileSync30, writeFileSync as writeFileSync22 } from "fs";
+import { createInterface as createInterface3 } from "readline";
 import { basename as basename18, join as join22, resolve as resolve46 } from "path";
 
 // cli/license.ts
-import { existsSync as existsSync25, mkdirSync as mkdirSync13, readFileSync as readFileSync29, unlinkSync as unlinkSync2, writeFileSync as writeFileSync21 } from "fs";
+import { existsSync as existsSync26, mkdirSync as mkdirSync13, readFileSync as readFileSync29, unlinkSync as unlinkSync2, writeFileSync as writeFileSync21 } from "fs";
 import { homedir as homedir8 } from "os";
 import { join as join21 } from "path";
 var VALID_TIERS = /* @__PURE__ */ new Set(["free", "pro", "team"]);
@@ -36780,16 +37274,16 @@ function licenseDir() {
 }
 function ensureLicenseDir() {
   const dir = licenseDir();
-  if (!existsSync25(dir)) mkdirSync13(dir, { recursive: true });
+  if (!existsSync26(dir)) mkdirSync13(dir, { recursive: true });
 }
 function licenseFilePath() {
   return join21(licenseDir(), "license.json");
 }
 function readStoredLicense() {
-  const path5 = licenseFilePath();
-  if (!existsSync25(path5)) return null;
+  const path7 = licenseFilePath();
+  if (!existsSync26(path7)) return null;
   try {
-    return JSON.parse(readFileSync29(path5, "utf-8"));
+    return JSON.parse(readFileSync29(path7, "utf-8"));
   } catch {
     return null;
   }
@@ -36882,8 +37376,8 @@ function storeLicenseFromToken(token) {
   };
 }
 function deactivateLicense() {
-  const path5 = licenseFilePath();
-  if (existsSync25(path5)) unlinkSync2(path5);
+  const path7 = licenseFilePath();
+  if (existsSync26(path7)) unlinkSync2(path7);
 }
 function tryBackgroundRefresh() {
   const stored = readStoredLicense();
@@ -36965,11 +37459,69 @@ function printProductionOutputNotice(commandPath) {
 function slugify(name) {
   return name.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "");
 }
+var PROJECT_VISIBILITIES = /* @__PURE__ */ new Set(["private", "shared", "public"]);
+function projectInitUsage() {
+  return "Usage: forgecad project init [name] [--slug <slug>] [--visibility <private|shared|public>]";
+}
+function parseProjectInitArgs(args, cwd) {
+  let name;
+  let slug2;
+  let visibility = "private";
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--slug") {
+      const value = args[++i];
+      if (!value || value.startsWith("-")) throw new Error(projectInitUsage());
+      slug2 = value;
+    } else if (arg.startsWith("--slug=")) {
+      slug2 = arg.slice("--slug=".length);
+      if (!slug2) throw new Error(projectInitUsage());
+    } else if (arg === "--visibility") {
+      const value = args[++i];
+      if (!value || value.startsWith("-")) throw new Error(projectInitUsage());
+      visibility = value;
+    } else if (arg.startsWith("--visibility=")) {
+      visibility = arg.slice("--visibility=".length);
+      if (!visibility) throw new Error(projectInitUsage());
+    } else if (arg.startsWith("-")) {
+      throw new Error(`Unknown project init option: ${arg}
+${projectInitUsage()}`);
+    } else if (!name) {
+      name = arg;
+    } else {
+      throw new Error(`Unexpected project init argument: ${arg}
+${projectInitUsage()}`);
+    }
+  }
+  name = (name ?? basename18(cwd)).trim();
+  slug2 = (slug2 ?? slugify(name)).trim();
+  if (!name) throw new Error("Project name cannot be empty.");
+  if (!slug2) throw new Error("Project slug cannot be empty. Pass --slug with a URL-safe name.");
+  if (!PROJECT_VISIBILITIES.has(visibility)) {
+    throw new Error(`Invalid project visibility "${visibility}". Expected private, shared, or public.`);
+  }
+  return { name, slug: slug2, visibility };
+}
+function localProjectName(cwd, manifest) {
+  return (manifest.name ?? manifest.slug ?? basename18(cwd)).trim();
+}
+function localProjectSlug(cwd, manifest) {
+  const slug2 = (manifest.slug ?? slugify(localProjectName(cwd, manifest))).trim();
+  if (!slug2) throw new Error("Project slug cannot be empty. Re-run `forgecad project init` with --slug.");
+  return slug2;
+}
+function localProjectVisibility(manifest) {
+  const visibility = manifest.visibility ?? "private";
+  if (!PROJECT_VISIBILITIES.has(visibility)) {
+    throw new Error(`Invalid project visibility "${visibility}" in forgecad.json. Expected private, shared, or public.`);
+  }
+  return visibility;
+}
 function padRight(s, w) {
   return s.length >= w ? s : s + " ".repeat(w - s.length);
 }
-function confirm(question) {
-  const rl = createInterface2({ input: process.stdin, output: process.stderr });
+function confirm2(question) {
+  const rl = createInterface3({ input: process.stdin, output: process.stderr });
   return new Promise((resolve54) => {
     rl.question(`${question} [y/N] `, (answer) => {
       rl.close();
@@ -36982,7 +37534,7 @@ function moveCandidateReasonLabel(candidate) {
   return candidate.reason === "same-content" ? "same content" : "same filename";
 }
 function promptChoice(question) {
-  const rl = createInterface2({ input: process.stdin, output: process.stderr });
+  const rl = createInterface3({ input: process.stdin, output: process.stderr });
   return new Promise((resolve54) => {
     rl.question(question, (answer) => {
       rl.close();
@@ -37099,44 +37651,19 @@ async function runProjectInitCli(args) {
     console.error(`Already a ForgeCAD project (slug: ${existing.slug}).`);
     process.exit(1);
   }
-  requireCliAuth();
-  let name;
-  let slug2;
-  let visibility = "private";
-  for (let i = 0; i < args.length; i++) {
-    if (args[i] === "--slug" && args[i + 1]) {
-      slug2 = args[++i];
-    } else if (args[i] === "--visibility" && args[i + 1]) {
-      visibility = args[++i];
-    } else if (!args[i].startsWith("-")) {
-      name = args[i];
-    }
-  }
-  name = name ?? basename18(cwd);
-  slug2 = slug2 ?? slugify(name);
-  console.log(`Creating project "${name}" (${slug2})...`);
   try {
-    const project = await createProject(slug2, name, visibility);
+    const { name, slug: slug2, visibility } = parseProjectInitArgs(args, cwd);
     const manifest = {
-      projectId: project.id,
-      slug: project.slug,
-      server: getServerUrl()
+      name,
+      slug: slug2,
+      server: getServerUrl(),
+      visibility
     };
     writeManifest(cwd, manifest);
-    const localFiles = scanLocalFiles(cwd);
-    if (localFiles.length > 0) {
-      console.log(`Pushing ${localFiles.length} file(s)...`);
-      for (const file of localFiles) {
-        await saveRemoteFile(project.id, file.path, file.content);
-        console.log(`  ${file.path}`);
-      }
-    }
-    const fileIds = await fetchFileIds(project.id);
-    writeManifest(cwd, { ...manifest, files: fileIds });
-    console.log(`\x1B[32mProject initialized.\x1B[0m`);
-    console.log(`  ID:   ${project.id}`);
-    console.log(`  Slug: ${project.slug}`);
-    console.log(`  URL:  ${getServerUrl()}/app/p/${project.id}`);
+    console.log(`\x1B[32mProject initialized locally.\x1B[0m`);
+    console.log(`  Name: ${name}`);
+    console.log(`  Slug: ${slug2}`);
+    console.log(`  Next: forgecad project push`);
   } catch (error) {
     console.error(`\x1B[31m${error instanceof Error ? error.message : "Init failed"}\x1B[0m`);
     process.exit(1);
@@ -37158,7 +37685,7 @@ async function runProjectCloneCli(args) {
       throw new Error(`Project "${slug2}" not found. Run \`forgecad project list\` to see available projects.`);
     }
     const targetDir = resolve46(slug2);
-    if (existsSync26(targetDir)) {
+    if (existsSync27(targetDir)) {
       throw new Error(`Directory "${slug2}" already exists.`);
     }
     mkdirSync14(targetDir, { recursive: true });
@@ -37187,7 +37714,7 @@ async function runProjectCloneCli(args) {
 }
 async function runProjectPullCli(args) {
   const cwd = process.cwd();
-  let manifest = requireManifest(cwd);
+  let manifest = requireRemoteManifest(cwd, "pull remote changes");
   requireCliAuth();
   const force = args.includes("--force") || args.includes("-f");
   if (!manifest.files) {
@@ -37224,7 +37751,7 @@ async function runProjectPullCli(args) {
     console.log(`
   ${incoming.length} file(s) will be overwritten locally.`);
     if (!force) {
-      const ok = await confirm("Proceed?");
+      const ok = await confirm2("Proceed?");
       if (!ok) {
         console.log("Aborted.");
         return;
@@ -37254,15 +37781,61 @@ async function runProjectPushCli(args) {
   requireCliAuth();
   const force = args.includes("--force") || args.includes("-f");
   const deleteMissing = args.includes("--delete-missing");
-  if (!manifest.files) {
-    console.log("Upgrading manifest to track file IDs...");
-    const fileIds = await fetchFileIds(manifest.projectId);
-    manifest = { ...manifest, files: fileIds };
-    writeManifest(cwd, manifest);
-  }
-  console.log(`Pushing to "${manifest.slug}"...`);
   try {
     const localFiles = scanLocalFiles(cwd);
+    if (!hasRemoteProject(manifest)) {
+      const name = localProjectName(cwd, manifest);
+      const slug2 = localProjectSlug(cwd, manifest);
+      const visibility = localProjectVisibility(manifest);
+      console.log(`Project "${name}" (${slug2}) has no hosted project yet.`);
+      if (localFiles.length > 0) {
+        for (const file of localFiles) {
+          console.log(`  \x1B[32m+ add   \x1B[0m ${file.path}`);
+        }
+        console.log(`  ${localFiles.length} file(s) will be uploaded.`);
+      } else {
+        console.log("  No local project files found; the hosted project will start empty.");
+      }
+      if (!force) {
+        const ok = await confirm2(`Create hosted project "${name}" and push now?`);
+        if (!ok) {
+          console.log("Aborted.");
+          return;
+        }
+      }
+      console.log(`Creating hosted project "${name}" (${slug2})...`);
+      const project = await createProject(slug2, name, visibility);
+      manifest = {
+        ...manifest,
+        projectId: project.id,
+        name,
+        slug: project.slug,
+        server: getServerUrl(),
+        visibility
+      };
+      writeManifest(cwd, manifest);
+      if (localFiles.length > 0) {
+        console.log(`Pushing ${localFiles.length} file(s)...`);
+        for (const file of localFiles) {
+          await saveRemoteFile(project.id, file.path, file.content);
+          console.log(`  ${file.path}`);
+        }
+      }
+      const fileIds2 = await fetchFileIds(project.id);
+      writeManifest(cwd, { ...manifest, files: fileIds2 });
+      console.log(`\x1B[32mProject pushed.\x1B[0m`);
+      console.log(`  ID:   ${project.id}`);
+      console.log(`  Slug: ${project.slug}`);
+      console.log(`  URL:  ${getServerUrl()}/app/p/${project.id}`);
+      return;
+    }
+    if (!manifest.files) {
+      console.log("Upgrading manifest to track file IDs...");
+      const fileIds2 = await fetchFileIds(manifest.projectId);
+      manifest = { ...manifest, files: fileIds2 };
+      writeManifest(cwd, manifest);
+    }
+    console.log(`Pushing to "${manifest.slug}"...`);
     let remoteFiles = await fetchRemoteFiles(manifest.projectId);
     let movedCount = 0;
     if (!deleteMissing && manifest.files && Object.keys(manifest.files).length > 0) {
@@ -37279,8 +37852,8 @@ Checking ${orphaned.length} missing tracked file(s) against ${untracked.length}
         }
         const remainingUntracked = [...untracked].sort((a, b) => a.path.localeCompare(b.path));
         const skippedMovePrompts = [];
-        const removeRemainingUntracked = (path5) => {
-          const index = remainingUntracked.findIndex((file) => file.path === path5);
+        const removeRemainingUntracked = (path7) => {
+          const index = remainingUntracked.findIndex((file) => file.path === path7);
           if (index >= 0) remainingUntracked.splice(index, 1);
         };
         for (const [fromPath, fileId] of orphaned) {
@@ -37304,7 +37877,7 @@ Checking ${orphaned.length} missing tracked file(s) against ${untracked.length}
           }
           if (candidates.length === 0 && remainingUntracked.length === 1) {
             const candidate = remainingUntracked[0];
-            const yes = await confirm(`Did you move ${fromPath} \u2192 ${candidate.path}?`);
+            const yes = await confirm2(`Did you move ${fromPath} \u2192 ${candidate.path}?`);
             if (yes) {
               remoteFiles = await applyProjectPushMove({ cwd, manifest, remoteFiles, fromPath, toPath: candidate.path, fileId });
               movedCount++;
@@ -37322,7 +37895,7 @@ Checking ${orphaned.length} missing tracked file(s) against ${untracked.length}
           }
           if (candidates.length === 1) {
             const candidate = candidates[0];
-            const yes = await confirm(`Did you move ${fromPath} \u2192 ${candidate.path} (${moveCandidateReasonLabel(candidate)})?`);
+            const yes = await confirm2(`Did you move ${fromPath} \u2192 ${candidate.path} (${moveCandidateReasonLabel(candidate)})?`);
             if (yes) {
               remoteFiles = await applyProjectPushMove({ cwd, manifest, remoteFiles, fromPath, toPath: candidate.path, fileId });
               movedCount++;
@@ -37360,7 +37933,7 @@ Checking ${orphaned.length} missing tracked file(s) against ${untracked.length}
       }
     } else if (deleteMissing && manifest.files && Object.keys(manifest.files).length > 0) {
       const localPathSet = new Set(localFiles.map((f2) => f2.path));
-      const missingTrackedCount = Object.keys(manifest.files).filter((path5) => !localPathSet.has(path5)).length;
+      const missingTrackedCount = Object.keys(manifest.files).filter((path7) => !localPathSet.has(path7)).length;
       if (missingTrackedCount > 0) {
         console.log(`
 --delete-missing: skipping move detection for ${missingTrackedCount} missing tracked file(s).`);
@@ -37399,7 +37972,7 @@ Checking ${orphaned.length} missing tracked file(s) against ${untracked.length}
       }
       console.log(`  ${outgoing.length} change(s) total.`);
       if (!force) {
-        const ok = await confirm("Push these changes?");
+        const ok = await confirm2("Push these changes?");
         if (!ok) {
           console.log("Aborted.");
           return;
@@ -37426,9 +37999,26 @@ Checking ${orphaned.length} missing tracked file(s) against ${untracked.length}
 async function runProjectStatusCli(_args) {
   const cwd = process.cwd();
   const manifest = requireManifest(cwd);
-  requireCliAuth();
   try {
     const localFiles = scanLocalFiles(cwd);
+    if (!hasRemoteProject(manifest)) {
+      console.log(`Project: ${manifest.slug}`);
+      console.log(`Server:  ${manifest.server}`);
+      console.log("Remote:  not created yet");
+      console.log(`Files:   ${localFiles.length} local`);
+      console.log("");
+      if (localFiles.length === 0) {
+        console.log("  Local-only project. Run `forgecad project push` to create the hosted project.");
+      } else {
+        for (const file of localFiles) {
+          console.log(`  \x1B[32m+ local  \x1B[0m ${file.path}`);
+        }
+        console.log("");
+        console.log(`  ${localFiles.length} file(s) will be uploaded when you run \`forgecad project push\`.`);
+      }
+      return;
+    }
+    requireCliAuth();
     const remoteFiles = await fetchRemoteFiles(manifest.projectId);
     const diffs = diffFiles(
       localFiles,
@@ -37463,7 +38053,7 @@ async function runProjectListCli(_args) {
   try {
     const projects = await listProjects();
     if (projects.length === 0) {
-      console.log("No projects. Create one with `forgecad project init`.");
+      console.log("No hosted projects. Run `forgecad project init` in a project folder, then `forgecad project push`.");
       return;
     }
     const idWidth = Math.max(2, ...projects.map((p) => p.id.length));
@@ -37512,6 +38102,11 @@ async function runProjectOpenCli(_args) {
     openBrowser2(url2);
     return;
   }
+  if (!hasRemoteProject(manifest)) {
+    console.error("This project has not been created on the server yet.");
+    console.error("  Run `forgecad studio .` for local editing, or `forgecad project push` to create the hosted project first.");
+    process.exit(1);
+  }
   const server = normalizeServerUrl(manifest.server || readStoredAuth()?.server || "https://forgecad.io", "Project server URL");
   const url = `${server}/app?project=${manifest.projectId}`;
   console.log(`Opening "${manifest.slug}" in browser...`);
@@ -37592,7 +38187,7 @@ return assembly('Project Assembly')
 };
 async function runProjectInfoCli(_args) {
   const cwd = process.cwd();
-  const manifest = requireManifest(cwd);
+  const manifest = requireRemoteManifest(cwd, "show project info");
   requireCliAuth();
   try {
     const project = await getProject(manifest.projectId);
@@ -37616,7 +38211,7 @@ async function runProjectInfoCli(_args) {
 }
 async function runProjectRenameCli(args) {
   const cwd = process.cwd();
-  const manifest = requireManifest(cwd);
+  const manifest = requireRemoteManifest(cwd, "rename it");
   requireCliAuth();
   let name;
   let slug2;
@@ -37645,7 +38240,7 @@ async function runProjectRenameCli(args) {
 }
 async function runProjectSetVisibilityCli(args) {
   const cwd = process.cwd();
-  const manifest = requireManifest(cwd);
+  const manifest = requireRemoteManifest(cwd, "change its visibility");
   requireCliAuth();
   const visibility = args.find((a) => !a.startsWith("-"));
   if (!visibility || !["private", "shared", "public"].includes(visibility)) {
@@ -37662,14 +38257,14 @@ async function runProjectSetVisibilityCli(args) {
 }
 async function runProjectDeleteCli(args) {
   const cwd = process.cwd();
-  const manifest = requireManifest(cwd);
+  const manifest = requireRemoteManifest(cwd, "delete it");
   requireCliAuth();
   const force = args.includes("--force") || args.includes("-f");
   try {
     const project = await getProject(manifest.projectId);
     if (!force) {
       console.log(`\x1B[31mThis will permanently delete project "${project.name}" (${project.slug}) and all its files.\x1B[0m`);
-      const ok = await confirm("Are you sure?");
+      const ok = await confirm2("Are you sure?");
       if (!ok) {
         console.log("Aborted.");
         return;
@@ -37684,7 +38279,7 @@ async function runProjectDeleteCli(args) {
 }
 async function runFileListCli(args) {
   const cwd = process.cwd();
-  const manifest = requireManifest(cwd);
+  const manifest = requireRemoteManifest(cwd, "list remote files");
   requireCliAuth();
   const filterPath = args.find((a) => !a.startsWith("-"));
   try {
@@ -37710,7 +38305,7 @@ async function runFileListCli(args) {
 }
 async function runFileReadCli(args) {
   const cwd = process.cwd();
-  const manifest = requireManifest(cwd);
+  const manifest = requireRemoteManifest(cwd, "read remote files");
   requireCliAuth();
   const filePath = args.find((a) => !a.startsWith("-"));
   if (!filePath) {
@@ -37727,7 +38322,7 @@ async function runFileReadCli(args) {
 }
 async function runFileSaveCli(args) {
   const cwd = process.cwd();
-  const manifest = requireManifest(cwd);
+  const manifest = requireRemoteManifest(cwd, "save remote files");
   requireCliAuth();
   let filePath;
   let content;
@@ -37755,7 +38350,7 @@ async function runFileSaveCli(args) {
       content = Buffer.concat(chunks).toString("utf-8");
     } else if (!content) {
       const localPath = join22(cwd, filePath);
-      if (!existsSync26(localPath)) {
+      if (!existsSync27(localPath)) {
         console.error(`Local file not found: ${filePath}`);
         console.error("Use --content or --stdin to provide content directly.");
         process.exit(1);
@@ -37771,7 +38366,7 @@ async function runFileSaveCli(args) {
 }
 async function runFileDeleteCli(args) {
   const cwd = process.cwd();
-  const manifest = requireManifest(cwd);
+  const manifest = requireRemoteManifest(cwd, "delete remote files");
   requireCliAuth();
   const force = args.includes("--force") || args.includes("-f");
   const filePath = args.find((a) => !a.startsWith("-"));
@@ -37781,7 +38376,7 @@ async function runFileDeleteCli(args) {
   }
   try {
     if (!force) {
-      const ok = await confirm(`Delete remote file "${filePath}"?`);
+      const ok = await confirm2(`Delete remote file "${filePath}"?`);
       if (!ok) {
         console.log("Aborted.");
         return;
@@ -37796,7 +38391,7 @@ async function runFileDeleteCli(args) {
 }
 async function runFileRenameCli(args) {
   const cwd = process.cwd();
-  const manifest = requireManifest(cwd);
+  const manifest = requireRemoteManifest(cwd, "rename remote files");
   requireCliAuth();
   const positionals = args.filter((a) => !a.startsWith("-"));
   if (positionals.length < 2) {
@@ -37816,7 +38411,7 @@ async function runFileRenameCli(args) {
 }
 async function runFileMkdirCli(args) {
   const cwd = process.cwd();
-  const manifest = requireManifest(cwd);
+  const manifest = requireRemoteManifest(cwd, "create remote folders");
   requireCliAuth();
   const dirPath = args.find((a) => !a.startsWith("-"));
   if (!dirPath) {
@@ -37833,7 +38428,7 @@ async function runFileMkdirCli(args) {
 }
 async function runFileCopyCli(args) {
   const cwd = process.cwd();
-  const manifest = requireManifest(cwd);
+  const manifest = requireRemoteManifest(cwd, "copy remote files");
   requireCliAuth();
   let destFilename;
   const positionals = [];
@@ -37865,7 +38460,7 @@ async function runFileCopyCli(args) {
 }
 async function runProjectMembersCli(_args) {
   const cwd = process.cwd();
-  const manifest = requireManifest(cwd);
+  const manifest = requireRemoteManifest(cwd, "manage members");
   requireCliAuth();
   try {
     const members = await listMembers(manifest.projectId);
@@ -37887,7 +38482,7 @@ async function runProjectMembersCli(_args) {
 }
 async function runProjectAddMemberCli(args) {
   const cwd = process.cwd();
-  const manifest = requireManifest(cwd);
+  const manifest = requireRemoteManifest(cwd, "add members");
   requireCliAuth();
   let email;
   let role = "editor";
@@ -37916,7 +38511,7 @@ async function runProjectAddMemberCli(args) {
 }
 async function runProjectRemoveMemberCli(args) {
   const cwd = process.cwd();
-  const manifest = requireManifest(cwd);
+  const manifest = requireRemoteManifest(cwd, "remove members");
   requireCliAuth();
   const email = args.find((a) => !a.startsWith("-"));
   if (!email) {
@@ -37938,7 +38533,7 @@ async function runProjectRemoveMemberCli(args) {
 }
 async function runProjectSetRoleCli(args) {
   const cwd = process.cwd();
-  const manifest = requireManifest(cwd);
+  const manifest = requireRemoteManifest(cwd, "change member roles");
   requireCliAuth();
   const positionals = args.filter((a) => !a.startsWith("-"));
   if (positionals.length < 2) {
@@ -37997,7 +38592,7 @@ async function runSharesDeleteCli(args) {
   }
   try {
     if (!force) {
-      const ok = await confirm(`Unpublish share "${shareId}"?`);
+      const ok = await confirm2(`Unpublish share "${shareId}"?`);
       if (!ok) {
         console.log("Aborted.");
         return;
@@ -38028,7 +38623,7 @@ async function runNewCli(args) {
   }
   name = name ?? `my-${template}`;
   const filename = name.endsWith(tmpl.ext) ? name : `${name}${tmpl.ext}`;
-  if (existsSync26(filename)) {
+  if (existsSync27(filename)) {
     console.error(`File already exists: ${filename}`);
     process.exit(1);
   }
@@ -38122,7 +38717,7 @@ async function runTokenRevokeCli(args) {
     process.exit(1);
   }
   if (!force) {
-    const ok = await confirm(`Revoke token "${token.name}"? Any CI/CD pipelines using it will stop working.`);
+    const ok = await confirm2(`Revoke token "${token.name}"? Any CI/CD pipelines using it will stop working.`);
     if (!ok) {
       console.log("Cancelled.");
       return;
@@ -38178,13 +38773,13 @@ function findCollisions(entries) {
   }
   return collisions;
 }
-function usage23() {
+function usage24() {
   console.error("Usage: forgecad check params <script.forge.js> [--samples N]");
   process.exit(1);
 }
 async function runParamCheckCli(argv = process.argv.slice(2)) {
   const scriptPath = argv[0];
-  if (!scriptPath) usage23();
+  if (!scriptPath) usage24();
   const samplesArg = argv.indexOf("--samples");
   const numSamples = samplesArg >= 0 ? parseInt(argv[samplesArg + 1], 10) : 8;
   const code = readFileSync31(resolve47(scriptPath), "utf-8");
@@ -38868,7 +39463,7 @@ function buildPrintCheckReport(objects, verifications, options) {
 }
 
 // cli/print-check.ts
-function usage24() {
+function usage25() {
   console.error(
     "Usage: forgecad check print <model.forge.js|asset.stl|asset.obj|asset.3mf|asset.step|asset.stp> [input ...] [--json] [--output report.json] [--profile fdm-pla-0.4mm] [--param Key=Value] [--joint JointName=Value]"
   );
@@ -38908,7 +39503,7 @@ function takeValue(argv, index, name) {
   }
   return value;
 }
-function parseArgs22(argv) {
+function parseArgs23(argv) {
   const { consumed: focusConsumed } = parseFocusFlags(argv);
   const consumed = new Set(focusConsumed);
   const profileOverrides = {};
@@ -39003,7 +39598,7 @@ function parseArgs22(argv) {
     }
   }
   const positional = argv.filter((arg, index) => !consumed.has(index) && !arg.startsWith("-"));
-  if (positional.length === 0) usage24();
+  if (positional.length === 0) usage25();
   const inputPaths = requireInputPaths(positional, "Missing input path.");
   requireRenderableInputPaths(inputPaths);
   requireSingleInputForOutputPath(inputPaths, outputPath);
@@ -39087,7 +39682,7 @@ function scriptErrorReport(scriptPath, message, profile, elapsedMs) {
   };
 }
 async function runPrintCheckCli(argv = process.argv.slice(2)) {
-  const args = parseArgs22(argv);
+  const args = parseArgs23(argv);
   requireExistingInputPaths(args.inputPaths);
   const profile = resolvePrintProfile(args.profileId, args.profileOverrides);
   const reports = [];
@@ -39322,7 +39917,7 @@ sys.exit(0 if ok else 1)
 }
 
 // cli/forge-pinocchio.ts
-function parseArgs23(argv) {
+function parseArgs24(argv) {
   const inputPaths = [];
   let outputPath;
   const paramOverrides = {};
@@ -39369,7 +39964,7 @@ function resolveSimulationModel6(result, jointOverrides) {
   return collectSimulationModel(def, { state: jointOverrides });
 }
 async function runPinocchioCli(argv = process.argv.slice(2)) {
-  const { inputPaths, outputPath, paramOverrides, jointOverrides } = parseArgs23(argv);
+  const { inputPaths, outputPath, paramOverrides, jointOverrides } = parseArgs24(argv);
   requireExistingInputPaths(inputPaths);
   let failures = 0;
   for (const [index, scriptPath] of inputPaths.entries()) {
@@ -39407,9 +40002,9 @@ async function exportPinocchioInput(scriptPath, explicitOutputPath, paramOverrid
 }
 
 // cli/sim-dynamics.ts
-import { existsSync as existsSync27, readFileSync as readFileSync33, statSync as statSync12 } from "fs";
+import { existsSync as existsSync28, readFileSync as readFileSync33, statSync as statSync12 } from "fs";
 import { join as join23, resolve as resolve50 } from "path";
-function parseArgs24(argv) {
+function parseArgs25(argv) {
   const inputPaths = [];
   let json = false;
   let compact = false;
@@ -39450,12 +40045,12 @@ function failedReport5(source, message, code, suggest) {
 }
 function resolveFeedbackPath2(inputPath) {
   const abs = resolve50(inputPath);
-  if (existsSync27(abs) && statSync12(abs).isDirectory()) return join23(abs, "feedback.json");
+  if (existsSync28(abs) && statSync12(abs).isDirectory()) return join23(abs, "feedback.json");
   return abs;
 }
 function ingest(inputPath) {
   const feedbackPath = resolveFeedbackPath2(inputPath);
-  if (!existsSync27(feedbackPath)) {
+  if (!existsSync28(feedbackPath)) {
     return failedReport5(
       inputPath,
       `No results at ${feedbackPath}.`,
@@ -39481,7 +40076,7 @@ function ingest(inputPath) {
   return { ...report, source: inputPath };
 }
 async function runSimDynamicsCli(argv = process.argv.slice(2)) {
-  const options = parseArgs24(argv);
+  const options = parseArgs25(argv);
   const reports = options.inputPaths.map((inputPath) => ingest(inputPath));
   printFeedback(reports.length === 1 ? reports[0] : { runs: reports }, options.json, options.compact);
   if (reports.some((report) => !report.ok) && !options.noFailExit) process.exitCode = 1;
@@ -39489,7 +40084,7 @@ async function runSimDynamicsCli(argv = process.argv.slice(2)) {
 
 // cli/sim-mass.ts
 var DEFAULT_DENSITY_KG_M35 = 1e3;
-function parseArgs25(argv) {
+function parseArgs26(argv) {
   const inputPaths = [];
   const paramOverrides = {};
   const jointOverrides = {};
@@ -39648,7 +40243,7 @@ function analyze2(source, options, objects) {
   };
 }
 async function runSimMassCli(argv = process.argv.slice(2)) {
-  const options = parseArgs25(argv);
+  const options = parseArgs26(argv);
   requireExistingInputPaths(options.inputPaths);
   await init();
   const reports = [];
@@ -39776,7 +40371,7 @@ function analyzeMechanism(input) {
 
 // cli/sim-mechanism.ts
 var DEFAULT_DENSITY_KG_M36 = 1e3;
-function parseArgs26(argv) {
+function parseArgs27(argv) {
   const inputPaths = [];
   const paramOverrides = {};
   const jointOverrides = {};
@@ -39871,7 +40466,7 @@ function flattenShapes(part, out) {
   else if (part instanceof ShapeGroup) part.children.forEach((child) => flattenShapes(child, out));
 }
 async function runSimMechanismCli(argv = process.argv.slice(2)) {
-  const options = parseArgs26(argv);
+  const options = parseArgs27(argv);
   requireExistingInputPaths(options.inputPaths);
   await init();
   const reports = [];
@@ -40317,7 +40912,7 @@ function resolveToleranceResponses(verifications, specOverrides) {
 }
 
 // cli/sim-tolerance.ts
-function parseArgs27(argv) {
+function parseArgs28(argv) {
   const inputPaths = [];
   const paramOverrides = {};
   const tolOverrides = /* @__PURE__ */ new Map();
@@ -40606,7 +41201,7 @@ async function analyze4(scriptPath, options) {
   };
 }
 async function runSimToleranceCli(argv = process.argv.slice(2)) {
-  const options = parseArgs27(argv);
+  const options = parseArgs28(argv);
   requireExistingInputPaths(options.inputPaths);
   await init();
   const reports = [];
@@ -41572,9 +42167,9 @@ function parseJointFlags2(argv) {
   }
   return { overrides, consumed };
 }
-function usage25() {
+function usage26() {
   console.error(
-    "Usage: forgecad run <model.forge.js|asset.stl|asset.obj|asset.3mf|asset.step|asset.stp> [input ...] [--details] [--history] [--features] [--connectivity] [--connectivity-tolerance <mm>] [--param Key=Value] [--joint JointName=Value] [--debug-imports] [--verbose|-v] [--backend manifold|occt|truck|sdf] [--quality live|default|high] [--solver-profile] [--solver-debug-out <dir>]"
+    "Usage: forgecad run <model.forge.js|asset.stl|asset.obj|asset.3mf|asset.step|asset.stp> [input ...] [--details] [--history] [--features] [--connectivity] [--connectivity-tolerance <mm>] [--param Key=Value] [--joint JointName=Value] [--project-root <dir>] [--debug-imports] [--verbose|-v] [--backend manifold|occt|truck|sdf] [--quality live|default|high] [--solver-profile] [--solver-debug-out <dir>]"
   );
   process.exit(1);
 }
@@ -41773,11 +42368,12 @@ async function runScriptCli(argv = process.argv.slice(2)) {
   const explicitBackend = parseBackendArg2(argv);
   const quality = parseQualityArg2(argv);
   const solverDebugOut = parseRequiredArg(argv, "--solver-debug-out");
+  const projectRoot = parseRequiredArg(argv, "--project-root");
   const positional = argv.filter(
-    (arg, i) => !paramConsumed.has(i) && !jointConsumed.has(i) && !focusConsumed.has(i) && !connectivityConsumed.has(i) && arg !== "--details" && arg !== "--history" && arg !== "--features" && arg !== "--solver-profile" && arg !== "--debug-imports" && arg !== "--journeys" && arg !== "--journeys-json" && arg !== "--verbose" && arg !== "-v" && arg !== "--backend" && argv[i - 1] !== "--backend" && arg !== "--quality" && argv[i - 1] !== "--quality" && arg !== "-q" && argv[i - 1] !== "-q" && arg !== "--solver-debug-out" && argv[i - 1] !== "--solver-debug-out"
+    (arg, i) => !paramConsumed.has(i) && !jointConsumed.has(i) && !focusConsumed.has(i) && !connectivityConsumed.has(i) && arg !== "--details" && arg !== "--history" && arg !== "--features" && arg !== "--solver-profile" && arg !== "--debug-imports" && arg !== "--journeys" && arg !== "--journeys-json" && arg !== "--verbose" && arg !== "-v" && arg !== "--backend" && argv[i - 1] !== "--backend" && arg !== "--quality" && argv[i - 1] !== "--quality" && arg !== "-q" && argv[i - 1] !== "-q" && arg !== "--solver-debug-out" && argv[i - 1] !== "--solver-debug-out" && arg !== "--project-root" && argv[i - 1] !== "--project-root"
   );
   const scriptPaths = positional;
-  if (scriptPaths.length === 0) usage25();
+  if (scriptPaths.length === 0) usage26();
   requireRenderableInputPaths(scriptPaths);
   requireExistingInputPaths(scriptPaths);
   if (scriptPaths.length > 1 && printJourneysJson) {
@@ -41799,7 +42395,7 @@ async function runScriptCli(argv = process.argv.slice(2)) {
           debugSvgSnapshots: true
         });
       }
-      const input = loadCliScriptInput(scriptPath);
+      const input = loadCliScriptInput(scriptPath, { projectRoot });
       activeBackend = resolveCliBackend(explicitBackend, input) ?? CLI_DEFAULT_BACKEND;
       await initCliBackend(activeBackend);
       resetSolverStats();
@@ -41988,13 +42584,36 @@ async function runScriptCli(argv = process.argv.slice(2)) {
         const connectivity = analyzePhysicalConnectivity2(entries, connectivityOptions);
         for (const line of formatPhysicalConnectivity(connectivity)) console.log(line);
       }
-      console.log(
-        `\u2713 Params: ${result.params.map((p) => {
-          const label = p.choices ? `${p.choices[p.value]}` : `${p.value}`;
-          const changed = p.value !== p.defaultValue ? " *" : "";
-          return `${p.name}=${label}${changed}`;
-        }).join(", ")}`
-      );
+      if (result.params.length > 0) {
+        console.log(
+          `\u2713 Params: ${result.params.map((p) => {
+            const label = p.choices ? `${p.choices[p.value]}` : `${p.value}`;
+            const changed = p.value !== p.defaultValue ? " *" : "";
+            return `${p.name}=${label}${changed}`;
+          }).join(", ")}`
+        );
+      }
+      if (result.stringParams.length > 0) {
+        console.log(`\u2713 String Params: ${result.stringParams.map((p) => `${p.name}=${JSON.stringify(p.value)}`).join(", ")}`);
+      }
+      if (result.listParams.length > 0) {
+        console.log(`\u2713 List Params: ${result.listParams.map((p) => `${p.name} (${p.items.length} rows)`).join(", ")}`);
+      }
+      if (result.path2dParams.length > 0) {
+        console.log(
+          `\u2713 Path Params: ${result.path2dParams.map((p) => `${p.name} (${p.points.length} ${p.closed ? "outline" : "centerline"} points)`).join(", ")}`
+        );
+      }
+      if (result.spline2dParams.length > 0) {
+        console.log(
+          `\u2713 Spline Params: ${result.spline2dParams.map((p) => `${p.name} (${p.points.length} points, degree ${p.degree})`).join(", ")}`
+        );
+      }
+      if (result.placement2dParams.length > 0) {
+        console.log(
+          `\u2713 Placement Params: ${result.placement2dParams.map((p) => `${p.name} (${p.items.length} items${p.zones.length > 0 ? `, ${p.zones.length} zones` : ""})`).join(", ")}`
+        );
+      }
       console.log(`\u2713 Time: ${result.timeMs.toFixed(0)}ms`);
       if (!printSolverProfile && solverDebugOut) {
         const bundles = await writeSolverDebugArtifacts(solverDebugOut, scriptPath, result.objects);
@@ -42155,7 +42774,7 @@ async function runScriptCli(argv = process.argv.slice(2)) {
 // cli/forge-render-section.ts
 import { writeFile as writeFile11 } from "fs/promises";
 import { basename as basename20, extname as extname16, resolve as resolve53 } from "path";
-function usage26() {
+function usage27() {
   console.error(
     "Usage: forgecad render section <model.forge.js|asset.stl|asset.obj|asset.3mf|asset.step|asset.stp> [input ...] [--output path] [--format svg|png] [--param Key=Value] [--joint JointName=Value] [--plane XY|XZ|YZ] [--offset <number>] [--size <px>] [--edges <off|thin|bold>] [--chrome-path <path>] [--background <color>]"
   );
@@ -42233,7 +42852,7 @@ function parseRenderSectionArgs(argv) {
       background = argv[++i];
     } else if (argv[i].startsWith("-")) {
       console.error(`Unknown option: ${argv[i]}`);
-      usage26();
+      usage27();
     } else {
       inputPaths.push(argv[i]);
     }
@@ -42324,7 +42943,7 @@ async function renderSectionInput(options, scriptPath, resolvedChromePath) {
 
 // cli/update-check.ts
 import { spawn as spawn4 } from "child_process";
-import { existsSync as existsSync28, mkdirSync as mkdirSync17, readFileSync as readFileSync34, writeFileSync as writeFileSync25 } from "fs";
+import { existsSync as existsSync29, mkdirSync as mkdirSync17, readFileSync as readFileSync34, writeFileSync as writeFileSync25 } from "fs";
 import { homedir as homedir9 } from "os";
 import { dirname as dirname15, join as join25 } from "path";
 var PACKAGE_NAME = "forgecad";
@@ -42348,7 +42967,7 @@ function readCache() {
 function writeCache(cache) {
   const p = cachePath();
   const dir = dirname15(p);
-  if (!existsSync28(dir)) mkdirSync17(dir, { recursive: true });
+  if (!existsSync29(dir)) mkdirSync17(dir, { recursive: true });
   writeFileSync25(p, JSON.stringify(cache), "utf-8");
 }
 function shouldSkip() {
@@ -43948,9 +44567,9 @@ var commands = [
     group: "Modeling",
     path: ["run"],
     summary: "Execute a Forge script quickly and print the inner-loop build summary: build count, verification results, parameters, and timing.",
-    description: "The fast validation command: runs the script with the real geometry kernel (no browser) and reports build status, object count, `verify.*` pass/fail with expected vs actual values (non-fatal \u2014 the model still renders), parameter values, script logs, and timing. Run it frequently while editing.\n\nA bare `forgecad run` skips expensive diagnostics. Opt in with `--details` (volumes/bounds), `--history` (construction tree), `--features` (feature tallies), `--solver-profile` (constraint solver timing), or `--connectivity` (physical connected components \u2014 bbox contact is evidence, exact geometry is checked by default). `--quality live|default|high` selects the same geometry quality profile as the editor and export tools; `live` is fastest for large models.\n\nDirect `.stl`/`.obj`/`.3mf`/`.step`/`.stp` inputs are imported automatically; STEP/STP auto-selects OCCT unless you pass `--backend`. For deeper confidence gates, prefer `inspect mechanical-integrity`, `check print`, or `inspect fit interference` instead of turning `run` into a catch-all audit command.",
+    description: "The fast validation command: runs the script with the real geometry kernel (no browser) and reports build status, object count, `verify.*` pass/fail with expected vs actual values (non-fatal \u2014 the model still renders), parameter values, script logs, and timing. Run it frequently while editing.\n\nA bare `forgecad run` skips expensive diagnostics. Opt in with `--details` (volumes/bounds), `--history` (construction tree), `--features` (feature tallies), `--solver-profile` (constraint solver timing), or `--connectivity` (physical connected components \u2014 bbox contact is evidence, exact geometry is checked by default). `--quality live|default|high` selects the same geometry quality profile as the editor and export tools; `live` is fastest for large models.\n\nDirect `.stl`/`.obj`/`.3mf`/`.step`/`.stp` inputs are imported automatically; STEP/STP auto-selects OCCT unless you pass `--backend`. Use `--project-root <dir>` when running a file inside a larger uninitialized folder and you intentionally want relative imports to resolve against that root. For deeper confidence gates, prefer `inspect mechanical-integrity`, `check print`, or `inspect fit interference` instead of turning `run` into a catch-all audit command.",
     usage: [
-      "forgecad run <model.forge.js|asset.stl|asset.obj|asset.3mf|asset.step|asset.stp> [input ...] [--details] [--history] [--features] [--connectivity] [--connectivity-tolerance <mm>] [--focus [names]] [--hide names] [--journeys] [--journeys-json] [--param Key=Value] [--joint JointName=Value] [--debug-imports] [--verbose] [--backend manifold|occt|truck|sdf] [--quality live|default|high] [--solver-profile] [--solver-debug-out <dir>]"
+      "forgecad run <model.forge.js|asset.stl|asset.obj|asset.3mf|asset.step|asset.stp> [input ...] [--details] [--history] [--features] [--connectivity] [--connectivity-tolerance <mm>] [--focus [names]] [--hide names] [--journeys] [--journeys-json] [--param Key=Value] [--joint JointName=Value] [--project-root <dir>] [--debug-imports] [--verbose] [--backend manifold|occt|truck|sdf] [--quality live|default|high] [--solver-profile] [--solver-debug-out <dir>]"
     ],
     examples: [
       "forgecad run examples/api/static-assembly-connectors.forge.js",
@@ -43964,6 +44583,7 @@ var commands = [
       "forgecad run examples/products/cup.forge.js --backend occt",
       "forgecad run examples/products/cup.forge.js --backend truck --quality live",
       "forgecad run examples/products/cup.forge.js --debug-imports",
+      "forgecad run assembly/main.forge.js --project-root .",
       'forgecad run examples/products/cup.forge.js -p "Wall Thickness=3" -p "Body Height=200"',
       "forgecad run examples/constraints/06-complex-spectrogram.forge.js --solver-debug-out tmp/spectrogram-debug"
     ],
@@ -43990,6 +44610,13 @@ var commands = [
           valueLabel: "<mm>"
         },
         { name: "--debug-imports", description: "Print the import trace" },
+        {
+          name: "--project-root",
+          description: "Project/import root for this run; enables intentional relative imports within that directory",
+          argument: "required",
+          valueLabel: "<dir>",
+          valueKind: "directory"
+        },
         { name: "--journeys", description: "Print model journey summaries declared with scene({ journeys })" },
         { name: "--journeys-json", description: "Emit machine-readable journey metadata and diagnostics only" },
         {
@@ -44509,11 +45136,22 @@ var commands = [
       options: [
         ...PARAM_OPTIONS,
         { name: "--study", description: "Run one named FEA study", argument: "required", valueLabel: "<name>" },
-        { name: "--output", description: "Output result root directory", argument: "required", valueLabel: "<dir>", valueKind: "directory" },
+        {
+          name: "--output",
+          description: "Output result root directory",
+          argument: "required",
+          valueLabel: "<dir>",
+          valueKind: "directory"
+        },
         { name: "--no-render", description: "Run solver and write reports without PNG render artifacts" },
         { name: "--camera", description: "Camera/view label for stress renders", argument: "required", valueLabel: "<view>" },
         { name: "--size", description: "Render image size in pixels", argument: "required", valueLabel: "<px>" },
-        { name: "--chrome-path", description: "Chrome/Chromium executable path for PNG rendering", argument: "required", valueLabel: "<path>" },
+        {
+          name: "--chrome-path",
+          description: "Chrome/Chromium executable path for PNG rendering",
+          argument: "required",
+          valueLabel: "<path>"
+        },
         { name: "--json", description: "Emit the FEA result index JSON" },
         { name: "--compact", description: "Minify JSON output" },
         { name: "--no-fail-exit", description: "Always exit 0 after writing the result bundle" }
@@ -44566,11 +45204,21 @@ var commands = [
             { value: "deformed", description: "CalculiX displacement shape" }
           ]
         },
-        { name: "--exaggerate", description: "Deformation exaggeration factor; requires --shape deformed", argument: "required", valueLabel: "<x>" },
+        {
+          name: "--exaggerate",
+          description: "Deformation exaggeration factor; requires --shape deformed",
+          argument: "required",
+          valueLabel: "<x>"
+        },
         { name: "--output", description: "Output PNG path", argument: "required", valueLabel: "<path>", valueKind: "path" },
         { name: "--camera", description: "Camera/view label for stress renders", argument: "required", valueLabel: "<view>" },
         { name: "--size", description: "Render image size in pixels", argument: "required", valueLabel: "<px>" },
-        { name: "--chrome-path", description: "Chrome/Chromium executable path for PNG rendering", argument: "required", valueLabel: "<path>" }
+        {
+          name: "--chrome-path",
+          description: "Chrome/Chromium executable path for PNG rendering",
+          argument: "required",
+          valueLabel: "<path>"
+        }
       ],
       positionals: [{ description: "FEA study result directory", valueKind: "directory" }]
     },
@@ -44585,10 +45233,20 @@ var commands = [
     completion: {
       options: [
         { name: "--output", description: "Output comparison directory", argument: "required", valueLabel: "<dir>", valueKind: "directory" },
-        { name: "--field", description: "Comparison field. Only safety is supported so scales stay locked.", argument: "required", valueLabel: "<safety>" },
+        {
+          name: "--field",
+          description: "Comparison field. Only safety is supported so scales stay locked.",
+          argument: "required",
+          valueLabel: "<safety>"
+        },
         { name: "--camera", description: "Shared render camera", argument: "required", valueLabel: "<name>" },
         { name: "--size", description: "Shared render image size in pixels", argument: "required", valueLabel: "<px>" },
-        { name: "--chrome-path", description: "Chrome/Chromium executable path for PNG rendering", argument: "required", valueLabel: "<path>" }
+        {
+          name: "--chrome-path",
+          description: "Chrome/Chromium executable path for PNG rendering",
+          argument: "required",
+          valueLabel: "<path>"
+        }
       ],
       positionals: [
         { description: "First FEA study result directory", valueKind: "directory" },
@@ -44607,7 +45265,13 @@ var commands = [
       options: [
         ...PARAM_OPTIONS,
         { name: "--study", description: "Run one named FEA study", argument: "required", valueLabel: "<name>" },
-        { name: "--output", description: "Output result root directory", argument: "required", valueLabel: "<dir>", valueKind: "directory" },
+        {
+          name: "--output",
+          description: "Output result root directory",
+          argument: "required",
+          valueLabel: "<dir>",
+          valueKind: "directory"
+        },
         { name: "--json", description: "Emit the FEA result index JSON" },
         { name: "--compact", description: "Minify JSON output" },
         { name: "--no-fail-exit", description: "Always exit 0 after writing the result bundle" }
@@ -45157,10 +45821,50 @@ var commands = [
     },
     run: runContextRenderCli
   },
+  {
+    group: "Project",
+    path: ["manual-edits"],
+    summary: "Read submitted manual parameter edits for a ForgeCAD entry file.",
+    description: "Agent-facing manual edit commands. The browser submits manual path and spline canvas edits when the user chooses Send to AI; these commands let a local agent read the exact point and G-continuity data before updating source defaults.",
+    usage: ["forgecad manual-edits <command>"],
+    examples: ["forgecad manual-edits status main.forge.js", "forgecad manual-edits get main.forge.js --format json"],
+    run: async () => {
+      console.error("`forgecad manual-edits` requires a subcommand.");
+      console.error("");
+      console.error("Available subcommands:");
+      console.error("  forgecad manual-edits get <model.forge.js> [--format text|json]");
+      console.error("  forgecad manual-edits status <model.forge.js> [--format text|json]");
+      process.exit(1);
+    }
+  },
+  {
+    group: "Project",
+    path: ["manual-edits", "get"],
+    summary: "Print the latest submitted manual parameter edits for one entry file.",
+    usage: ["forgecad manual-edits get <model.forge.js> [--format text|json]"],
+    examples: ["forgecad manual-edits get main.forge.js", "forgecad manual-edits get main.forge.js --format json"],
+    completion: {
+      positionals: [{ description: "ForgeCAD entry file", valueKind: "file" }],
+      options: [{ name: "--format", description: "Output format", argument: "required", valueLabel: "<text|json>" }]
+    },
+    run: runManualEditsGetCli
+  },
+  {
+    group: "Project",
+    path: ["manual-edits", "status"],
+    summary: "Show whether one entry file has submitted manual parameter edits.",
+    usage: ["forgecad manual-edits status <model.forge.js> [--format text|json]"],
+    examples: ["forgecad manual-edits status main.forge.js", "forgecad manual-edits status main.forge.js --format json"],
+    completion: {
+      positionals: [{ description: "ForgeCAD entry file", valueKind: "file" }],
+      options: [{ name: "--format", description: "Output format", argument: "required", valueLabel: "<text|json>" }]
+    },
+    run: runManualEditsStatusCli
+  },
   {
     group: "Project",
     path: ["project", "init"],
-    summary: "Initialize the current directory as a ForgeCAD project and create it on the server.",
+    summary: "Initialize the current directory as a local ForgeCAD project.",
     usage: ["forgecad project init [name] [--slug <slug>] [--visibility <private|shared|public>]"],
     examples: ["forgecad project init", 'forgecad project init "My Gearbox" --slug my-gearbox'],
     completion: {
@@ -45210,7 +45914,7 @@ var commands = [
   {
     group: "Project",
     path: ["project", "push"],
-    summary: "Upload local changes to the remote project.",
+    summary: "Create the hosted project if needed, then upload local changes.",
     usage: ["forgecad project push [--force] [--delete-missing]"],
     examples: ["forgecad project push", "forgecad project push --delete-missing"],
     completion: {
@@ -46384,7 +47088,7 @@ var commands = [
         { name: "--update", description: "Regenerate compiler snapshots" }
       ]
     },
-    run: async (args) => (await import("./check-compiler-7YAHVXYM.js")).runCheckCompilerCli(args)
+    run: async (args) => (await import("./check-compiler-UJWUEIDC.js")).runCheckCompilerCli(args)
   },
   {
     group: "Checks",
@@ -46407,7 +47111,7 @@ var commands = [
         { name: "--update", description: "Regenerate query-propagation snapshots" }
       ]
     },
-    run: async (args) => (await import("./check-query-propagation-ZRR6IOJW.js")).runCheckQueryPropagationCli(args)
+    run: async (args) => (await import("./check-query-propagation-O2EPDJSY.js")).runCheckQueryPropagationCli(args)
   },
   {
     group: "Checks",
@@ -46825,8 +47529,8 @@ function isOptionToken(value) {
   return /^--?[A-Za-z]/.test(value);
 }
 function supportsEqualsOptionSyntax(command, optionName) {
-  const path5 = command.path.join(" ");
-  return (path5 === "signup" || path5 === "login") && optionName === "--server" || path5 === "login" && optionName === "--token" || path5 === "skill install" && optionName === "--target";
+  const path7 = command.path.join(" ");
+  return (path7 === "signup" || path7 === "login") && optionName === "--server" || path7 === "login" && optionName === "--token" || path7 === "skill install" && optionName === "--target";
 }
 function validateCommandArgs(command, args) {
   if (command.hidden) return;
@@ -46993,17 +47697,17 @@ function oclifSummaryFor(command) {
 function stripAnsiCodes(value) {
   return value.replace(/\x1b\[[0-9;]*m/g, "");
 }
-function commandPathId(path5) {
-  return path5.join(" ");
+function commandPathId(path7) {
+  return path7.join(" ");
 }
-function findCommandDefinition(path5) {
-  const id = commandPathId(path5);
+function findCommandDefinition(path7) {
+  const id = commandPathId(path7);
   return commands.find((command) => !command.hidden && commandPathId(command.path) === id);
 }
-function commandOrTopicSummary(path5) {
-  const command = findCommandDefinition(path5);
+function commandOrTopicSummary(path7) {
+  const command = findCommandDefinition(path7);
   if (command) return oclifSummaryFor(command);
-  return TOPIC_DESCRIPTIONS[commandPathId(path5)];
+  return TOPIC_DESCRIPTIONS[commandPathId(path7)];
 }
 function visibleChildCommands(topicPath) {
   return commands.filter((command) => {
@@ -47051,7 +47755,7 @@ function topicNameForHelp(topic) {
 var ForgeCadHelp = class extends Help {
   async showRootHelp() {
     const groupSections = ROOT_HELP_GROUPS.map(({ heading, paths }) => {
-      const rows = paths.map((path5) => [`forgecad ${commandPathId(path5)}`, commandOrTopicSummary(path5)]);
+      const rows = paths.map((path7) => [`forgecad ${commandPathId(path7)}`, commandOrTopicSummary(path7)]);
       return `${heading}
 ${helpRows(rows)}`;
     });