fix: apply committed build blocks under auto detection, doc fixes from review

app build with a config build block but no declared framework now detects
the framework the way deploy does instead of silently ignoring the block
(FRAMEWORK_NOT_DETECTED when nothing is detectable). Docs: retire
APP_CONFIG_INVALID in favor of the COMPUTE_CONFIG_*/BUILD_SETTINGS_* codes
and scope auto-creation (resolution step 7) to app deploy only.

Author: AmanVarshney01

docs/product/command-spec.md

@@ -113,7 +113,7 @@ Preview app commands that need an app resolve it in this order:
 4. locally selected app for non-deploy commands when it still exists in the resolved branch
 5. inferred app name from `package.json#name`
 6. current directory name
-7. create the inferred app in the resolved branch when no existing app matches
+7. `app deploy` only: create the inferred app in the resolved branch when no existing app matches
 8. interactive picker only when multiple matching apps make the target ambiguous
 9. `APP_AMBIGUOUS` in non-interactive or `--json` mode when unresolved
 
@@ -123,7 +123,8 @@ upward config discovery as `app deploy`: the project binding is read from the
 config file's directory, and the config target is an additional app-name
 source. Unlike deploy, management commands never require a target: with
 multiple targets, no argument, and nothing inferred from the invocation
-directory, they fall back to the selection order above.
+directory, they fall back to the selection order above — except step 7;
+management commands never create apps or mutate remote state to resolve one.
 
 `.prisma/local.json` pins the directory to a Workspace and Project only. It does
 not pin an App ID. App services are branch-scoped; a service ID from `main`

docs/product/error-conventions.md

@@ -170,7 +170,11 @@ These codes are the minimum stable set for the MVP:
 - `LOCAL_STATE_WRITE_FAILED`
 - `LOCAL_STATE_STALE`
 - `BRANCH_NOT_DEPLOYABLE`
-- `APP_CONFIG_INVALID`
+- `COMPUTE_CONFIG_INVALID`
+- `COMPUTE_CONFIG_TARGET_REQUIRED`
+- `COMPUTE_CONFIG_TARGET_UNKNOWN`
+- `BUILD_SETTINGS_MIGRATION_REQUIRED`
+- `BUILD_SETTINGS_UNSUPPORTED`
 - `FRAMEWORK_NOT_DETECTED`
 - `DEPLOYMENT_NOT_FOUND`
 - `NO_DEPLOYMENTS`

packages/cli/src/controllers/app.ts

@@ -161,7 +161,17 @@ export async function runAppBuild(
     target: compute.target,
   });
   const appDir = await resolveComputeAppDir(context, compute);
-  const buildType = normalizeBuildType(merged.buildType);
+  let buildType = normalizeBuildType(merged.buildType);
+  if (compute.target?.build && buildType === "auto") {
+    // A committed build block must never be silently ignored, so resolve the
+    // framework the same way deploy does instead of deferring to the
+    // strategy's auto detection.
+    const detected = await detectDeployFramework(appDir, context.runtime.signal);
+    if (!detected) {
+      throw frameworkNotDetectedError(appDir);
+    }
+    buildType = detected.buildType;
+  }
   assertSupportedEntrypoint(buildType, merged.entrypoint, "build");
 
   if (compute.target?.build && buildType !== "auto") {

packages/cli/tests/app-local-dev.test.ts

@@ -151,6 +151,82 @@ describe("app local dev commands", () => {
     });
   });
 
+  it("build applies a committed build block by detecting the framework instead of ignoring it", async () => {
+    const executePreviewBuild = vi.fn().mockResolvedValue({
+      artifact: {
+        directory: "/tmp/compute-build/app",
+        entrypoint: "server.js",
+      },
+      buildType: "nextjs",
+    });
+
+    vi.doMock("../src/lib/app/preview-build", async () => {
+      const actual = await vi.importActual<typeof import("../src/lib/app/preview-build")>(
+        "../src/lib/app/preview-build",
+      );
+      return {
+        ...actual,
+        executePreviewBuild,
+      };
+    });
+
+    const { createTempCwd, createTestCommandContext } = await import("./helpers");
+    const { runAppBuild } = await import("../src/controllers/app");
+    const cwd = await createTempCwd();
+    await mkdir(path.join(cwd, "apps", "web"), { recursive: true });
+    await writeFile(path.join(cwd, "apps", "web", "package.json"), JSON.stringify({
+      name: "web",
+      dependencies: { next: "15.0.0" },
+    }), "utf8");
+    // No framework declared: the build block still applies via detection.
+    await writeFile(path.join(cwd, "prisma.compute.ts"), [
+      "export default {",
+      '  apps: {',
+      '    web: { root: "apps/web", build: { command: "echo custom-build", outputDirectory: "out" } },',
+      "  },",
+      "};",
+      "",
+    ].join("\n"), "utf8");
+    const { context } = await createTestCommandContext({
+      cwd,
+      stateDir: path.join(cwd, ".state"),
+    });
+
+    await runAppBuild(context, { configTarget: "web" });
+
+    expect(executePreviewBuild).toHaveBeenCalledWith(expect.objectContaining({
+      appPath: path.join(cwd, "apps", "web"),
+      buildType: "nextjs",
+      buildSettings: expect.objectContaining({
+        buildCommand: "echo custom-build",
+        outputDirectory: "out",
+      }),
+    }));
+  });
+
+  it("build fails clearly when a build block exists but no framework is detectable", async () => {
+    const { createTempCwd, createTestCommandContext } = await import("./helpers");
+    const { runAppBuild } = await import("../src/controllers/app");
+    const cwd = await createTempCwd();
+    await mkdir(path.join(cwd, "apps", "mystery"), { recursive: true });
+    await writeFile(path.join(cwd, "prisma.compute.ts"), [
+      "export default {",
+      '  apps: {',
+      '    mystery: { root: "apps/mystery", build: { command: "make build", outputDirectory: "out" } },',
+      "  },",
+      "};",
+      "",
+    ].join("\n"), "utf8");
+    const { context } = await createTestCommandContext({
+      cwd,
+      stateDir: path.join(cwd, ".state"),
+    });
+
+    await expect(runAppBuild(context, { configTarget: "mystery" })).rejects.toMatchObject({
+      code: "FRAMEWORK_NOT_DETECTED",
+    });
+  });
+
   it("build accepts explicit SDK framework strategies", async () => {
     const executePreviewBuild = vi.fn().mockResolvedValue({
       artifact: {