feat(project): dispatch build on the project's managedBy backend

agentcore.json already records `managedBy` (CDK is the only value today), but
nothing read it: build() hardcoded the CDK path, so adding a terraform or
no-IaC backend later would have meant editing that path instead of adding
alongside it.

Carry managedBy on Project and switch on it in build(), delegating the CDK
work to a private buildWithCdk(). The default arm assigns to `never`, so a new
ManagedBySchema member fails to compile until it has an arm here.

Author: notgitika

src/core/project/manager.test.ts

@@ -273,6 +273,18 @@ describe("FsProjectManager.build", () => {
     expect(commands).toEqual([]);
   });
 
+  test("refuses a project managed by a backend it cannot build", async () => {
+    const directory = await inTempDirectory();
+    const { manager: subject, commands } = manager();
+    const project = await scaffolded(subject, directory);
+    commands.length = 0;
+
+    // CDK is the only backend today; the cast stands in for a future one.
+    const foreign = { ...project, managedBy: "Terraform" as Project["managedBy"] };
+    await expect(drain(subject.build(foreign))).rejects.toThrow(/unsupported backend: Terraform/);
+    expect(commands).toEqual([]);
+  });
+
   test("propagates a synthesis failure", async () => {
     const directory = await inTempDirectory();
     const { manager: subject } = manager();
@@ -300,6 +312,7 @@ describe("FsProjectManager.resolve", () => {
 
     expect(resolved?.name).toBe("example");
     expect(resolved?.rootPath).toBe(join(root, "example"));
+    expect(resolved?.managedBy).toBe("CDK");
     expect(resolved?.runtimes).toHaveLength(1);
   });
 

src/core/project/manager.tsx

@@ -54,7 +54,12 @@ export class FsProjectManager implements ProjectManager {
     const configPath = join(rootPath, "agentcore", "agentcore.json");
     try {
       const spec = await this.json.read(configPath, ProjectSpecSchema);
-      return { name: spec.name, rootPath, runtimes: spec.runtimes };
+      return {
+        name: spec.name,
+        rootPath,
+        managedBy: spec.managedBy,
+        runtimes: spec.runtimes,
+      };
     } catch (error) {
       // A malformed agentcore.json is a user-correctable problem, not a crash.
       if (error instanceof DeserializationError) {
@@ -119,6 +124,25 @@ export class FsProjectManager implements ProjectManager {
   }
 
   public async *build(project: Project): AsyncGenerator<ProjectEvent, void> {
+    // agentcore.json records which backend owns the project's artifacts. CDK is the
+    // only one today; a terraform or no-IaC backend adds an arm here rather than
+    // editing the CDK path.
+    switch (project.managedBy) {
+      case "CDK":
+        yield* this.buildWithCdk(project);
+        break;
+      default: {
+        // Exhaustiveness: a new ManagedBy member fails to compile until it is handled.
+        const unsupported: never = project.managedBy;
+        throw new ProjectStateError(
+          `project '${project.name}' declares an unsupported backend: ${String(unsupported)}`,
+        );
+      }
+    }
+  }
+
+  // Compiles the generated CDK app and synthesizes its CloudFormation templates.
+  private async *buildWithCdk(project: Project): AsyncGenerator<ProjectEvent, void> {
     const cdkDir = join(project.rootPath, "agentcore", "cdk");
 
     // The generated CDK app is built from its own node_modules; without them the

src/handlers/project/types.ts

@@ -1,3 +1,4 @@
+import type { ManagedBy } from "../../projectSchemas/project";
 import type { ProjectRuntime } from "../../projectSchemas/runtime";
 
 /** Available project templates for scaffolding new AgentCore projects. */
@@ -33,6 +34,8 @@ export type Project = {
   name: string;
   /** Absolute path to the project root (the parent of agentcore/). */
   rootPath: string;
+  /** The infrastructure backend that owns the project's deployable artifacts. */
+  managedBy: ManagedBy;
   /** The runtimes registered in agentcore.json. */
   runtimes: ProjectRuntime[];
 };