@openagentpack/sdk 0.3.2 → 0.4.0

package/dist/index.js

@@ -58,10 +58,10 @@ var BaseApiClient = class {
     if (this.isConflict(res.status, body)) throw new ConflictError(res.status, body, this.errorPrefix);
     throw new ApiError(res.status, body, this.errorPrefix);
   }
-  async post(path, body) {
+  async post(path, body, options) {
     const res = await resolveFetch()(`${this.baseUrl}${path}`, {
       method: "POST",
-      headers: this.headers(),
+      headers: { ...this.headers(), ...options?.headers },
       body: JSON.stringify(body)
     });
     await this.throwIfError(res);
@@ -2059,6 +2059,13 @@ function mapEnvironment2(name, decl, projectName) {
     metadata: injectMetadata(decl.metadata, projectName, name)
   };
 }
+function mapForwardEnvironment(name, decl, projectName) {
+  const body = mapEnvironment2(name, decl, projectName);
+  const config = { ...body.config };
+  delete config.networking;
+  body.config = config;
+  return body;
+}
 function mapVault(name, decl, projectName) {
   const body = { display_name: decl.display_name };
   if (projectName) body.metadata = injectMetadata(decl.metadata, projectName, name);
@@ -2373,10 +2380,12 @@ function mapForwardTemplate(name, decl, refs, projectName) {
     environment_id: refs.environment_id,
     vault_ids: refs.vault_ids
   };
+  body.files = Object.fromEntries((refs.file_ids ?? []).map((id) => [id, { enabled: true }]));
   if (refs.tunnel_id) body.tunnel_id = refs.tunnel_id;
   if (projectName) body.metadata = injectMetadata(decl.metadata, projectName, name);
   else body.metadata = decl.metadata ?? {};
   if (decl.environment_variables) body.environment_variables = decl.environment_variables;
+  if (decl.managed_tool_config) body.managed_tool_config = decl.managed_tool_config;
   if (decl.tools) {
     body.tools = [
       {
@@ -2565,6 +2574,7 @@ var QoderAdapter = class _QoderAdapter {
   client;
   memoryApi;
   forwardClient;
+  forwardMemoryApi;
   projectName;
   forwardSessionIds = /* @__PURE__ */ new Set();
   constructor(apiKey, gateway, projectName, forwardGateway) {
@@ -2586,6 +2596,19 @@ var QoderAdapter = class _QoderAdapter {
       apiKey,
       gateway: forwardGateway ?? deriveForwardGateway(gateway)
     });
+    this.forwardMemoryApi = new ProviderMemoryApi(this.forwardClient, {
+      pathStyle: "relative",
+      cursorParam: "after_id",
+      updatePrecondition: "content_sha256",
+      prefixParam: "prefix",
+      versionsSegment: "versions",
+      storeMetadataMode: "merge_patch",
+      supportsView: false,
+      supportsMemoryMetadata: true,
+      supportsPathUpdate: false,
+      supportsDeletePrecondition: false,
+      supportsIncludeArchived: true
+    });
     this.projectName = projectName ?? "";
   }
   async validate() {
@@ -2600,7 +2623,7 @@ var QoderAdapter = class _QoderAdapter {
     file: "/files",
     deployment: "/deployments"
   };
-  async findResource(type, name, id) {
+  async findResource(type, name, id, mode) {
     if (type === "template") {
       const raw2 = await locateRemote(this.forwardClient, "/templates", name, id, (item) => item.status !== "archived");
       return raw2 ? toRemoteResource(raw2) : null;
@@ -2620,7 +2643,14 @@ var QoderAdapter = class _QoderAdapter {
       const raw2 = await locateRemote(this.forwardClient, "/channels", name, id, () => true);
       return raw2 ? toRemoteResource(raw2) : null;
     }
-    const raw = await locateRemote(this.client, _QoderAdapter.ENDPOINT_MAP[type], name, id, notArchived);
+    if (type === "environment" && id && mode === "auto") {
+      const managed = await locateRemote(this.client, "/environments", name, id, notArchived);
+      if (managed) return toRemoteResource(managed);
+      const forward = await locateRemote(this.forwardClient, "/environments", name, id, notArchived);
+      return forward ? toRemoteResource(forward) : null;
+    }
+    const client = mode === "forward" && (type === "environment" || type === "skill" || type === "vault" || type === "memory_store" || type === "file") ? this.forwardClient : this.client;
+    const raw = await locateRemote(client, _QoderAdapter.ENDPOINT_MAP[type], name, id, notArchived);
     return raw ? toRemoteResource(raw) : null;
   }
   async listAgents(filter) {
@@ -2764,16 +2794,21 @@ var QoderAdapter = class _QoderAdapter {
     }
     if (type === "channel") {
       const channelConfig = raw.channel_config ?? {};
-      return compactDeep({
-        identity_id: raw.identity_id,
-        template_id: raw.template_id,
+      const mode = raw.identity_resolution?.mode ?? "fixed";
+      const normalized = {
+        identity_resolution: { mode },
         channel_type: raw.channel_type,
         name: raw.name,
         enabled: raw.enabled,
         channel_config: {
           response_options: channelConfig.response_options ?? {}
         }
-      });
+      };
+      if (mode === "fixed") {
+        normalized.identity_id = raw.identity_id;
+        normalized.template_id = raw.template_id;
+      }
+      return compactDeep(normalized);
     }
     return compactDeep({
       description: raw.description,
@@ -2784,24 +2819,29 @@ var QoderAdapter = class _QoderAdapter {
       metadata: stripAgentsMetadata(raw.metadata)
     });
   }
-  async createEnvironment(name, decl) {
-    const body = mapEnvironment2(name, decl, this.projectName);
-    const res = await this.client.post("/environments", body);
+  async createEnvironment(name, decl, mode = "managed") {
+    const body = mode === "forward" ? mapForwardEnvironment(name, decl, this.projectName) : mapEnvironment2(name, decl, this.projectName);
+    const res = await (mode === "forward" ? this.forwardClient : this.client).post("/environments", body);
     return toRemoteResource(res);
   }
-  async updateEnvironment(id, name, decl) {
-    const body = mapEnvironment2(name, decl, this.projectName);
-    const current = await this.client.get(`/environments/${id}`);
+  async updateEnvironment(id, name, decl, mode = "managed") {
+    const body = mode === "forward" ? mapForwardEnvironment(name, decl, this.projectName) : mapEnvironment2(name, decl, this.projectName);
+    const client = mode === "forward" ? this.forwardClient : this.client;
+    const current = await client.get(`/environments/${id}`);
     const currentMetadata = current.metadata ?? {};
     const metadata = { ...body.metadata ?? {} };
     for (const key of Object.keys(currentMetadata)) {
       if (!key.startsWith("agents.") && !(key in metadata)) metadata[key] = null;
     }
     body.metadata = metadata;
-    const res = await this.client.post(`/environments/${id}`, body);
+    const res = await client.post(`/environments/${id}`, body);
     return toRemoteResource(res);
   }
-  async deleteEnvironment(id, cascade = false) {
+  async deleteEnvironment(id, cascade = false, mode = "managed") {
+    if (mode === "forward") {
+      await this.forwardClient.delete(`/environments/${id}`);
+      return;
+    }
     try {
       await this.client.delete(`/environments/${id}`);
       return;
@@ -2828,17 +2868,18 @@ var QoderAdapter = class _QoderAdapter {
       await this.client.post(`/environments/${id}/archive`, {});
     }
   }
-  async createVault(name, decl) {
+  async createVault(name, decl, mode = "managed") {
+    const client = mode === "forward" ? this.forwardClient : this.client;
     const body = mapVault(name, decl, this.projectName);
-    const res = await this.client.post("/vaults", body);
+    const res = await client.post("/vaults", body);
     const vaultId = res.id;
     for (const cred of decl.credentials ?? []) {
-      await this.client.post(`/vaults/${vaultId}/credentials`, mapCredential(cred));
+      await client.post(`/vaults/${vaultId}/credentials`, mapCredential(cred));
     }
     return toRemoteResource(res);
   }
-  async deleteVault(id) {
-    await this.client.delete(`/vaults/${id}`);
+  async deleteVault(id, mode = "managed") {
+    await (mode === "forward" ? this.forwardClient : this.client).delete(`/vaults/${id}`);
   }
   async exportResources(type) {
     return exportRemoteResources(this.client, type, {
@@ -2849,17 +2890,24 @@ var QoderAdapter = class _QoderAdapter {
       agentToDecl: agentToDecl2
     });
   }
-  async createSkill(name, decl, files) {
+  async createSkill(name, decl, files, mode = "managed") {
     const formData = await buildSkillFormData(name, decl, files);
-    const res = await this.client.postFormData("/skills", formData);
+    const res = await (mode === "forward" ? this.forwardClient : this.client).postFormData(
+      "/skills",
+      formData
+    );
     return toRemoteResource(res);
   }
-  async updateSkill(id, name, decl, files) {
-    await this.client.delete(`/skills/${id}`);
-    return this.createSkill(name, decl, files);
+  async updateSkill(id, name, decl, files, mode = "managed") {
+    const client = mode === "forward" ? this.forwardClient : this.client;
+    const packageName = skillNameFromFiles(files) ?? name;
+    const formData = await buildSkillFormData(packageName, decl, files, "files", false, true);
+    await client.postFormData(`/skills/${id}/versions`, formData);
+    const current = await client.get(`/skills/${id}`);
+    return toRemoteResource(current);
   }
-  async deleteSkill(id) {
-    await this.client.delete(`/skills/${id}`);
+  async deleteSkill(id, mode = "managed") {
+    await (mode === "forward" ? this.forwardClient : this.client).delete(`/skills/${id}`);
   }
   async createAgent(name, decl, refs) {
     const body = mapAgent2(name, decl, refs, void 0, this.projectName);
@@ -2876,21 +2924,89 @@ var QoderAdapter = class _QoderAdapter {
     await this.client.delete(`/agents/${id}`);
   }
   async createTemplate(name, decl, refs) {
-    await this.registerForwardVaults(refs.vault_ids);
     const body = mapForwardTemplate(name, decl, refs, this.projectName);
     const res = await this.forwardClient.post("/templates", body);
+    await this.reconcileForwardMemoryMounts(res.id, refs);
     return toRemoteResource(res);
   }
   async updateTemplate(id, name, decl, refs) {
-    await this.registerForwardVaults(refs.vault_ids);
     const body = mapForwardTemplate(name, decl, refs, this.projectName);
     if (!refs.tunnel_id) body.tunnel_id = null;
     const res = await this.forwardClient.post(`/templates/${id}`, body);
+    await this.reconcileForwardMemoryMounts(id, refs);
     return toRemoteResource(res);
   }
-  async archiveTemplate(id) {
+  async archiveTemplate(id, ownedMemoryStoreIds = []) {
+    const owned = new Set(ownedMemoryStoreIds);
+    if (owned.size > 0) {
+      for (const identity of await this.forwardClient.getAllPaged("/identities")) {
+        if (typeof identity.id !== "string") continue;
+        const path = `/identities/${identity.id}/templates/${id}/memory_stores`;
+        try {
+          const mounts = await this.forwardClient.get(path);
+          for (const mount of mounts.data ?? []) {
+            const storeId = mount.memory_store_id;
+            if (mount.system_managed !== true && typeof storeId === "string" && owned.has(storeId)) {
+              await this.forwardClient.delete(`${path}/${storeId}`);
+            }
+          }
+        } catch (error) {
+          if (!ApiError.isNotFound(error)) throw error;
+        }
+      }
+    }
     await this.forwardClient.post(`/templates/${id}/archive`, {});
   }
+  async reconcileForwardMemoryMounts(templateId, refs) {
+    if (refs.memory_store_ids === void 0) return;
+    const desired = new Set(refs.memory_store_ids ?? []);
+    if (!refs.identity_id) {
+      if (desired.size > 0) throw new UserError("Qoder Forward Memory Store mounts require an Identity.");
+      return;
+    }
+    const path = `/identities/${refs.identity_id}/templates/${templateId}/memory_stores`;
+    const current = await this.forwardClient.get(path);
+    const explicit = (current.data ?? []).filter((mount) => mount.system_managed !== true);
+    const owned = new Set(refs.owned_memory_store_ids ?? refs.memory_store_ids ?? []);
+    for (const mount of explicit) {
+      const storeId = mount.memory_store_id;
+      if (typeof storeId === "string" && owned.has(storeId) && !desired.has(storeId)) {
+        await this.forwardClient.delete(`${path}/${storeId}`);
+      }
+    }
+    const mounted = new Set(
+      explicit.map((mount) => mount.memory_store_id).filter((id) => typeof id === "string")
+    );
+    for (const memoryStoreId of desired) {
+      if (!mounted.has(memoryStoreId)) await this.forwardClient.post(path, { memory_store_id: memoryStoreId });
+    }
+  }
+  async reconcileDefaultMemoryStore(identityId, templateId, desired) {
+    const storeId = await this.findDefaultMemoryStoreId(identityId, templateId);
+    if (!storeId) return { status: "pending" };
+    const current = await this.forwardClient.get(`/memory_stores/${storeId}`);
+    const descriptionChanged = desired.description !== void 0 && current.description !== desired.description;
+    if (current.name === desired.name && !descriptionChanged) {
+      return { status: "unchanged", memory_store_id: storeId };
+    }
+    await this.forwardClient.post(`/memory_stores/${storeId}`, {
+      name: desired.name,
+      ...desired.description !== void 0 ? { description: desired.description } : {}
+    });
+    return { status: "updated", memory_store_id: storeId };
+  }
+  async findDefaultMemoryStoreId(identityId, templateId) {
+    const mounts = await this.forwardClient.get(
+      `/identities/${identityId}/templates/${templateId}/memory_stores`
+    );
+    const writableDefault = (mounts.data ?? []).find(
+      (mount) => mount.system_managed === true && mount.access === "read_write"
+    );
+    return typeof writableDefault?.memory_store_id === "string" ? writableDefault.memory_store_id : null;
+  }
+  async deleteDefaultMemoryStore(id) {
+    await this.client.delete(`/memory_stores/${id}`);
+  }
   async createIdentity(name, decl) {
     if (decl.identity_id) return { id: decl.identity_id, type: "identity" };
     const res = await this.forwardClient.post("/identities", {
@@ -2927,12 +3043,14 @@ var QoderAdapter = class _QoderAdapter {
   }
   async updateChannel(id, name, decl, refs) {
     const current = await this.forwardClient.get(`/channels/${id}`);
-    if (current.channel_type !== decl.type) {
+    const currentMode = current.identity_resolution?.mode ?? "fixed";
+    if (current.channel_type !== decl.type || currentMode !== (decl.mode ?? "fixed")) {
       await this.deleteChannel(id);
       return this.createChannel(name, decl, refs);
     }
     const body = this.mapChannel(name, decl, refs);
     delete body.channel_type;
+    delete body.identity_resolution;
     const res = await this.forwardClient.post(`/channels/${id}`, body);
     return toRemoteResource(res);
   }
@@ -2940,9 +3058,8 @@ var QoderAdapter = class _QoderAdapter {
     await this.forwardClient.delete(`/channels/${id}`);
   }
   mapChannel(name, decl, refs) {
-    return {
-      identity_id: refs.identity_id,
-      template_id: refs.agent_id,
+    const mode = decl.mode ?? "fixed";
+    const body = {
       channel_type: decl.type,
       name: decl.name ?? name,
       enabled: decl.enabled ?? true,
@@ -2955,22 +3072,27 @@ var QoderAdapter = class _QoderAdapter {
         }
       }
     };
-  }
-  async registerForwardVaults(vaultIds) {
-    for (const id of vaultIds) {
-      await this.forwardClient.post("/resources/registry", {
-        type: "vault",
-        resource: { id }
-      });
+    if (mode === "pairing") {
+      body.identity_resolution = { mode: "pairing" };
+    } else {
+      body.identity_id = refs.identity_id;
+      body.template_id = refs.agent_id;
     }
+    return body;
   }
-  async createMemoryStore(name, decl) {
+  async createMemoryStore(name, decl, mode = "managed") {
     const body = mapMemoryStore2(name, decl);
-    const res = await this.client.post("/memory_stores", body);
+    const client = mode === "forward" ? this.forwardClient : this.client;
+    const memoryApi = mode === "forward" ? this.forwardMemoryApi : this.memoryApi;
+    const res = await client.post(
+      "/memory_stores",
+      body,
+      mode === "forward" ? { headers: { "Idempotency-Key": crypto.randomUUID() } } : void 0
+    );
     const storeId = res.id;
     try {
       for (const entry of decl.entries ?? []) {
-        await this.memoryApi.createMemory(storeId, { content: entry.content, path: entry.key });
+        await memoryApi.createMemory(storeId, { content: entry.content, path: entry.key });
       }
     } catch (error) {
       await this.client.delete(`/memory_stores/${storeId}`).catch(() => void 0);
@@ -2978,7 +3100,7 @@ var QoderAdapter = class _QoderAdapter {
     }
     return toRemoteResource(res);
   }
-  async deleteMemoryStore(id) {
+  async deleteMemoryStore(id, _mode = "managed") {
     await this.client.delete(`/memory_stores/${id}`);
   }
   listMemoryStores(options) {
@@ -2987,23 +3109,23 @@ var QoderAdapter = class _QoderAdapter {
   getMemoryStore(id) {
     return this.memoryApi.getStore(id);
   }
-  updateMemoryStore(id, input) {
-    return this.memoryApi.updateStore(id, input);
+  updateMemoryStore(id, input, mode = "managed") {
+    return (mode === "forward" ? this.forwardMemoryApi : this.memoryApi).updateStore(id, input);
   }
   archiveMemoryStore(id) {
     return this.memoryApi.archiveStore(id);
   }
-  createMemory(storeId, input) {
-    return this.memoryApi.createMemory(storeId, input);
+  createMemory(storeId, input, mode = "managed") {
+    return (mode === "forward" ? this.forwardMemoryApi : this.memoryApi).createMemory(storeId, input);
   }
-  listMemories(storeId, options) {
-    return this.memoryApi.listMemories(storeId, options);
+  listMemories(storeId, options, mode = "managed") {
+    return (mode === "forward" ? this.forwardMemoryApi : this.memoryApi).listMemories(storeId, options);
   }
   getMemory(storeId, memoryId) {
     return this.memoryApi.getMemory(storeId, memoryId);
   }
-  updateMemory(storeId, memoryId, input) {
-    return this.memoryApi.updateMemory(storeId, memoryId, input);
+  updateMemory(storeId, memoryId, input, mode = "managed") {
+    return (mode === "forward" ? this.forwardMemoryApi : this.memoryApi).updateMemory(storeId, memoryId, input);
   }
   deleteMemory(storeId, memoryId, expected) {
     return this.memoryApi.deleteMemory(storeId, memoryId, expected);
@@ -3292,30 +3414,42 @@ var QoderAdapter = class _QoderAdapter {
     return res.data;
   }
   // --- Files ---
-  async uploadFile(filePath, options) {
+  async uploadFile(filePath, options, mode = "managed") {
+    if (mode === "forward" && options?.purpose && !["user_upload", "session_resource"].includes(options.purpose)) {
+      throw new UserError(
+        `Qoder Forward File purpose must be 'user_upload' or 'session_resource', got '${options.purpose}'.`
+      );
+    }
     const resolved = resolve2(filePath);
     const content = readFileSync2(resolved);
     const fileName = options?.name ?? basename2(resolved);
-    return this.uploadFileContent(new Uint8Array(content), fileName, {
-      purpose: options?.purpose
-    });
+    const formData = buildFileFormData(new Uint8Array(content), fileName, { purpose: options?.purpose });
+    const res = await (mode === "forward" ? this.forwardClient : this.client).postFormData(
+      "/files",
+      formData
+    );
+    return toRestFileInfo(res);
   }
   async uploadFileContent(content, filename, options) {
-    const formData = new FormData();
-    const bytes = new Uint8Array(content);
-    formData.append(
-      "file",
-      options?.mimeType ? new File([bytes], filename, { type: options.mimeType }) : new File([bytes], filename)
-    );
-    if (filename) formData.append("name", filename);
-    if (options?.purpose) formData.append("purpose", options.purpose);
+    const formData = buildFileFormData(content, filename, options);
     const res = await this.client.postFormData("/files", formData);
     return toRestFileInfo(res);
   }
-  async deleteFile(id) {
-    await this.client.delete(`/files/${id}`);
+  async deleteFile(id, mode = "managed") {
+    await (mode === "forward" ? this.forwardClient : this.client).delete(`/files/${id}`);
   }
 };
+function buildFileFormData(content, filename, options) {
+  const formData = new FormData();
+  const bytes = new Uint8Array(content);
+  formData.append(
+    "file",
+    options?.mimeType ? new File([bytes], filename, { type: options.mimeType }) : new File([bytes], filename)
+  );
+  if (filename) formData.append("name", filename);
+  if (options?.purpose) formData.append("purpose", options.purpose);
+  return formData;
+}
 function toSessionInfo2(res) {
   return buildSessionInfo(res, (r) => r.memory_store_ids ?? []);
 }
@@ -3365,22 +3499,24 @@ function normalizeQoderMcpServers(value) {
     });
   });
 }
-async function buildSkillFormData(name, decl, files) {
+async function buildSkillFormData(name, decl, files, fileField = "file", includeCreateFields = true, prefixTopLevelDirectory = false) {
   const zip = new JSZip2();
   for (const f of files) {
-    zip.file(f.relativePath, f.content);
+    zip.file(prefixTopLevelDirectory ? `${name}/${f.relativePath}` : f.relativePath, f.content);
   }
   const zipContent = await zip.generateAsync({ type: "uint8array" });
   const formData = new FormData();
   formData.append(
-    "file",
+    fileField,
     new File([new Uint8Array(zipContent)], `${name}.zip`, {
       type: "application/zip"
     })
   );
-  formData.append("name", name);
-  formData.append("type", "custom");
-  if (decl.description) formData.append("description", decl.description);
+  if (includeCreateFields) {
+    formData.append("name", name);
+    formData.append("type", "custom");
+    if (decl.description) formData.append("description", decl.description);
+  }
   return formData;
 }
 
@@ -4057,7 +4193,7 @@ var BailianAdapter = class _BailianAdapter {
   }
   async waitForFileReady(fileId) {
     const start = Date.now();
-    let delay2 = FILE_SCAN_BACKOFF.initial;
+    let delay3 = FILE_SCAN_BACKOFF.initial;
     let logged = false;
     while (true) {
       const detail = await this.client.get(`/files/${fileId}`);
@@ -4076,8 +4212,8 @@ var BailianAdapter = class _BailianAdapter {
         );
         return;
       }
-      await new Promise((r) => setTimeout(r, delay2));
-      delay2 = Math.min(delay2 * FILE_SCAN_BACKOFF.factor, FILE_SCAN_BACKOFF.max);
+      await new Promise((r) => setTimeout(r, delay3));
+      delay3 = Math.min(delay3 * FILE_SCAN_BACKOFF.factor, FILE_SCAN_BACKOFF.max);
     }
   }
   // --- Vault (Vaults API) ---
@@ -5556,6 +5692,9 @@ var agentSkillRefSchema = z5.object({
 var agentDeliverySchema = z5.object({
   type: z5.enum(["managed", "forward"])
 });
+var managedToolConfigSchema = z5.object({
+  enabled_tools: z5.array(z5.string().min(1))
+});
 var sessionGithubRepoResourceSchema = z5.object({
   type: z5.literal("github_repository"),
   url: z5.string().url(),
@@ -5577,19 +5716,27 @@ var agentSchema = z5.object({
   mcp_servers: z5.array(mcpServerSchema).optional(),
   skills: z5.array(z5.union([z5.string(), agentSkillRefSchema])).optional(),
   vault: z5.string().optional(),
+  files: z5.array(z5.string()).optional(),
   memory_stores: z5.array(z5.string()).optional(),
+  default_memory_store: z5.object({
+    name: z5.string().trim().min(1).max(255),
+    description: z5.string().max(1024).optional(),
+    delete_on_destroy: z5.boolean().optional().default(false)
+  }).optional(),
   resources: z5.array(sessionGithubRepoResourceSchema).optional(),
   multiagent: multiagentSchema.optional(),
   metadata: z5.record(z5.string(), z5.string()).optional(),
   environment_variables: z5.record(z5.string().min(1), z5.string()).optional(),
+  managed_tool_config: managedToolConfigSchema.optional(),
   delivery: z5.record(z5.string(), agentDeliverySchema).optional()
 });
 var channelSchema = z5.object({
   provider: z5.string().optional(),
-  agent: z5.string().min(1),
+  agent: z5.string().min(1).optional(),
   identity: z5.string().min(1).optional(),
   type: z5.string().min(1),
   name: z5.string().trim().min(1).optional(),
+  mode: z5.enum(["fixed", "pairing"]).optional().default("fixed"),
   enabled: z5.boolean().optional(),
   credentials: z5.record(z5.string(), coerceString).optional(),
   options: z5.record(z5.string(), z5.unknown()).optional()
@@ -5828,15 +5975,24 @@ async function computeResourceHash(address, config, basePath, state) {
   if (!decl) return "";
   if (address.type === "skill") {
     const skillDecl = decl;
+    const apiMode = resolveQoderApiMode(address.type, address.name, address.provider, config);
     if (basePath) {
       const fileHash = computeSkillContentHash(skillDecl.source, basePath);
-      return contentHash({ decl, fileHash });
+      return contentHash({ decl, fileHash, apiMode });
     }
+    return contentHash({ decl, apiMode });
+  }
+  if (address.type === "environment" || address.type === "vault" || address.type === "memory_store") {
+    return contentHash({ decl, apiMode: resolveQoderApiMode(address.type, address.name, address.provider, config) });
   }
   if (address.type === "file" && basePath) {
     const fileDecl = decl;
     const fileHash = computeLocalFileContentHash(fileDecl.source, basePath);
-    return contentHash({ decl, fileHash });
+    return contentHash({
+      decl,
+      fileHash,
+      apiMode: resolveQoderApiMode("file", address.name, address.provider, config)
+    });
   }
   if (address.type === "deployment") {
     const refs = resolveDeploymentReferenceIds(decl, config, address.provider, state);
@@ -5858,13 +6014,28 @@ async function computeResourceHash(address, config, basePath, state) {
   }
   return contentHash(decl);
 }
+function resolveQoderApiMode(type, name, provider, config) {
+  if (provider !== "qoder") return void 0;
+  if (type === "environment" && config.environments?.[name]?.environment_id) return "auto";
+  for (const agent of Object.values(config.agents ?? {})) {
+    if (agent.provider && agent.provider !== provider) continue;
+    const referenced = type === "environment" ? agent.environment === name : type === "skill" ? agent.skills?.some(
+      (skill) => typeof skill === "string" ? skill === name : skill.type === "custom" && skill.skill_id === name
+    ) : type === "vault" ? agent.vault === name : type === "memory_store" ? agent.memory_stores?.includes(name) : agent.files?.includes(name);
+    if (referenced && agent.delivery?.qoder?.type === "forward") return "forward";
+  }
+  return "managed";
+}
 function computeReplacementFingerprint(address, config) {
   if (address.type !== "channel") return void 0;
   const decl = config.channels?.[address.name];
   if (!decl) return void 0;
-  return contentHash({ channel_type: decl.type, credentials: decl.credentials ?? {} });
+  return contentHash({ channel_type: decl.type, mode: decl.mode ?? "fixed", credentials: decl.credentials ?? {} });
 }
 function resolveChannelReferenceIds(decl, config, provider, state) {
+  if (decl.mode === "pairing" || !decl.agent) {
+    return { mode: "pairing" };
+  }
   const agent = config.agents?.[decl.agent];
   const agentType = agent?.delivery?.[provider]?.type === "forward" ? "template" : "agent";
   const identity = decl.identity ?? config.defaults?.identity;
@@ -5887,7 +6058,14 @@ function resolveTemplateReferenceIds(decl, config, provider, state) {
     environment_id: environment?.environment_id ?? (decl.environment ? state?.getResource({ type: "environment", name: decl.environment, provider })?.remote_id ?? void 0 : void 0),
     tunnel_id: tunnel?.tunnel_id,
     vault_ids: decl.vault ? [state?.getResource({ type: "vault", name: decl.vault, provider })?.remote_id ?? decl.vault] : [],
-    skill_ids: skillIds
+    skill_ids: skillIds,
+    memory_store_ids: (decl.memory_stores ?? []).map(
+      (memoryStore) => state?.getResource({ type: "memory_store", name: memoryStore, provider })?.remote_id ?? memoryStore
+    ),
+    file_ids: (decl.files ?? []).map(
+      (file) => state?.getResource({ type: "file", name: file, provider })?.remote_id ?? file
+    ),
+    identity_id: decl.memory_stores?.length && config.defaults?.identity ? state?.getResource({ type: "identity", name: config.defaults.identity, provider })?.remote_id : void 0
   };
 }
 function resolveDeploymentReferenceIds(decl, config, provider, state) {
@@ -6067,11 +6245,21 @@ function resolveTemplateRefs(agentName, config, provider, state) {
   const environment = config.environments?.[agent.environment];
   if (!environment) throw new UserError(`Environment '${agent.environment}' is not defined in config.`);
   const agentRefs = resolveAgentRefs(agentName, config, provider, state);
+  const memoryStoreIds = (agent.memory_stores ?? []).map(
+    (memoryStore) => requireRef(state, { type: "memory_store", name: memoryStore, provider })
+  );
+  const identityName = config.defaults?.identity;
   return {
     ...agentRefs,
     environment_id: environment.environment_id ?? requireRef(state, { type: "environment", name: agent.environment, provider }),
     ...agent.tunnel ? { tunnel_id: resolveTunnelIdFromConfig(config, agent.tunnel, provider) } : {},
-    vault_ids: agent.vault ? [requireRef(state, { type: "vault", name: agent.vault, provider })] : []
+    vault_ids: agent.vault ? [requireRef(state, { type: "vault", name: agent.vault, provider })] : [],
+    file_ids: (agent.files ?? []).map((file) => requireRef(state, { type: "file", name: file, provider })),
+    memory_store_ids: memoryStoreIds,
+    owned_memory_store_ids: state.listResources().filter(
+      (resource) => resource.address.provider === provider && resource.address.type === "memory_store" && resource.api_mode === "forward" && typeof resource.remote_id === "string"
+    ).map((resource) => resource.remote_id),
+    ...identityName ? { identity_id: requireRef(state, { type: "identity", name: identityName, provider }) } : {}
   };
 }
 function resolveDeploymentRefs(deploymentName, config, provider, state) {
@@ -6133,6 +6321,12 @@ function resolveDeploymentRefs(deploymentName, config, provider, state) {
 function resolveChannelRefs(channelName, config, provider, state) {
   const channel = config.channels?.[channelName];
   if (!channel) throw new UserError(`Channel '${channelName}' not found in config`);
+  if (channel.mode === "pairing") {
+    return {};
+  }
+  if (!channel.agent) {
+    throw new UserError(`Channel '${channelName}' is fixed mode and must declare agent`);
+  }
   const agent = config.agents?.[channel.agent];
   if (!agent) throw new UserError(`Channel '${channelName}' references unknown agent '${channel.agent}'`);
   const agentType = agent.delivery?.[provider]?.type === "forward" ? "template" : "agent";
@@ -6255,6 +6449,7 @@ async function executePlan(plan, ctx, options = {}) {
     await runWithConcurrency(level, concurrency, runAction);
     await ctx.state.save();
   }
+  await reconcileDefaultMemoryStores(ctx, new Set(plan.actions.map((action) => action.address.provider)));
   for (const action of deletions) {
     await runAction(action);
     await ctx.state.save();
@@ -6265,6 +6460,41 @@ async function executePlan(plan, ctx, options = {}) {
     partial: results.some((r) => r.status === "failed")
   };
 }
+async function reconcileDefaultMemoryStores(ctx, plannedProviders) {
+  const identityName = ctx.config.defaults?.identity;
+  for (const [agentName, agent] of Object.entries(ctx.config.agents ?? {})) {
+    const desired = agent.default_memory_store;
+    if (!desired || agent.delivery?.qoder?.type !== "forward") continue;
+    const providerName = "qoder";
+    if (agent.provider && agent.provider !== providerName || !plannedProviders.has(providerName)) continue;
+    const provider = ctx.providers.get(providerName);
+    if (!provider?.reconcileDefaultMemoryStore || !identityName) continue;
+    const identityId = ctx.state.getResource({
+      type: "identity",
+      name: identityName,
+      provider: providerName
+    })?.remote_id;
+    const templateId = ctx.state.getResource({ type: "template", name: agentName, provider: providerName })?.remote_id;
+    if (!identityId || !templateId) continue;
+    const result = await provider.reconcileDefaultMemoryStore(identityId, templateId, desired);
+    const resource = { type: "template", name: agentName, provider: providerName };
+    if (result.status === "pending") {
+      emitRuntimeFeedback(ctx.onFeedback, {
+        type: "provider_wait",
+        level: "warning",
+        resource,
+        message: `default memory store for template.${agentName} is pending \u2014 create the first Forward Session, then run apply again`
+      });
+    } else if (result.status === "updated") {
+      emitRuntimeFeedback(ctx.onFeedback, {
+        type: "resource_action_success",
+        level: "success",
+        resource,
+        message: `updated default memory store for template.${agentName} to "${desired.name}"`
+      });
+    }
+  }
+}
 async function runWithConcurrency(items, limit, worker) {
   if (items.length === 0) return;
   let cursor = 0;
@@ -6343,6 +6573,7 @@ async function executeActionInner(action, provider, ctx) {
     const existing = ctx.state.getResource(address);
     if (!existing) return false;
     const id = existing.remote_id;
+    const apiMode2 = existing.api_mode;
     if (type === "environment" || type === "identity") {
       const externalReference = type === "environment" ? ctx.config.environments?.[name]?.environment_id : ctx.config.identities?.[name]?.identity_id;
       if (existing.externally_managed || externalReference) {
@@ -6354,13 +6585,13 @@ async function executeActionInner(action, provider, ctx) {
       try {
         switch (type) {
           case "environment":
-            await provider.deleteEnvironment(id);
+            await provider.deleteEnvironment(id, false, apiMode2);
             break;
           case "vault":
-            await provider.deleteVault(id);
+            await provider.deleteVault(id, apiMode2);
             break;
           case "skill":
-            await provider.deleteSkill(id);
+            await provider.deleteSkill(id, apiMode2);
             break;
           case "agent":
             await provider.deleteAgent(id);
@@ -6368,17 +6599,17 @@ async function executeActionInner(action, provider, ctx) {
           case "template":
             if (!provider.archiveTemplate)
               throw new UserError(`Provider '${address.provider}' does not support templates`);
-            await provider.archiveTemplate(id);
+            await provider.archiveTemplate(id, ownedForwardMemoryStoreIds(ctx, address.provider));
             break;
           case "memory_store":
             if (!provider.deleteMemoryStore) throw memoryStoreUnsupported(address.provider);
-            await provider.deleteMemoryStore(id);
+            await provider.deleteMemoryStore(id, apiMode2);
             break;
           case "deployment":
             await provider.deleteDeployment(id);
             break;
           case "file":
-            await provider.deleteFile(id);
+            await provider.deleteFile(id, apiMode2);
             break;
           case "identity":
             if (!provider.deleteIdentity)
@@ -6407,6 +6638,9 @@ async function executeActionInner(action, provider, ctx) {
   const isUpdate = action.action === "update";
   const priorAddress = action.previousAddress ?? address;
   const existingId = isUpdate ? ctx.state.getResource(priorAddress)?.remote_id : void 0;
+  const apiMode = resolveResourceApiMode(type, name, address.provider, ctx.config);
+  const priorApiMode = ctx.state.getResource(priorAddress)?.api_mode ?? (address.provider === "qoder" ? "managed" : void 0);
+  const apiModeChanged = isUpdate && apiMode !== void 0 && priorApiMode !== apiMode;
   let result;
   switch (type) {
     case "environment": {
@@ -6421,6 +6655,17 @@ async function executeActionInner(action, provider, ctx) {
           resource: action.address,
           message: `${action.action} ${action.address.type}.${action.address.name} (${action.address.provider}) \u2014 external reference, no remote mutation`
         });
+      } else if (apiModeChanged) {
+        try {
+          result = await provider.createEnvironment(remoteName, decl, apiMode);
+        } catch (err) {
+          result = await adoptOnConflict(err, address, provider, ctx.onFeedback, {
+            mode: apiMode,
+            onExisting: (existing) => provider.updateEnvironment(existing.id, remoteName, decl, apiMode)
+          });
+          adopted = true;
+        }
+        if (existingId) await provider.deleteEnvironment(existingId, false, priorApiMode);
       } else if (isUpdate) {
         const prior = ctx.state.getResource(address);
         if (prior?.externally_managed) {
@@ -6428,13 +6673,14 @@ async function executeActionInner(action, provider, ctx) {
             `environment.${name} is recorded as an external reference (${prior.remote_id ?? "unknown id"}); refusing to modify it remotely. Restore 'environment_id' to keep it as a reference, or release it first with 'agents state rm environment.${name}' (then 'agents state import' to adopt it as a managed resource).`
           );
         }
-        result = await provider.updateEnvironment(existingId, remoteName, decl);
+        result = await provider.updateEnvironment(existingId, remoteName, decl, apiMode);
       } else {
         try {
-          result = await provider.createEnvironment(remoteName, decl);
+          result = await provider.createEnvironment(remoteName, decl, apiMode);
         } catch (err) {
           result = await adoptOnConflict(err, address, provider, ctx.onFeedback, {
-            onExisting: (existing) => provider.updateEnvironment(existing.id, remoteName, decl)
+            mode: apiMode,
+            onExisting: (existing) => provider.updateEnvironment(existing.id, remoteName, decl, apiMode)
           });
           adopted = true;
         }
@@ -6443,22 +6689,26 @@ async function executeActionInner(action, provider, ctx) {
     }
     case "vault": {
       const decl = ctx.config.vaults[name];
-      if (isUpdate) {
+      if (apiModeChanged) {
+        result = await provider.createVault(name, decl, apiMode);
+        if (existingId) await provider.deleteVault(existingId, priorApiMode).catch(() => void 0);
+      } else if (isUpdate) {
         try {
-          result = await provider.createVault(name, decl);
-          await provider.deleteVault(existingId);
+          result = await provider.createVault(name, decl, apiMode);
+          await provider.deleteVault(existingId, apiMode);
         } catch {
-          await provider.deleteVault(existingId);
-          result = await provider.createVault(name, decl);
+          await provider.deleteVault(existingId, apiMode);
+          result = await provider.createVault(name, decl, apiMode);
         }
       } else {
         try {
-          result = await provider.createVault(name, decl);
+          result = await provider.createVault(name, decl, apiMode);
         } catch (err) {
           result = await adoptOnConflict(err, address, provider, ctx.onFeedback, {
+            mode: apiMode,
             onExisting: async (existing) => {
-              await provider.deleteVault(existing.id);
-              return provider.createVault(name, decl);
+              await provider.deleteVault(existing.id, apiMode);
+              return provider.createVault(name, decl, apiMode);
             }
           });
           adopted = true;
@@ -6482,12 +6732,15 @@ async function executeActionInner(action, provider, ctx) {
       }
       const remoteName = decl.name ?? name;
       const files = await resolveSkillFiles(decl, ctx);
-      if (isUpdate) {
-        result = await provider.updateSkill(existingId, remoteName, decl, files);
+      if (apiModeChanged) {
+        result = await provider.createSkill(remoteName, decl, files, apiMode);
+        if (existingId) await provider.deleteSkill(existingId, priorApiMode).catch(() => void 0);
+      } else if (isUpdate) {
+        result = await provider.updateSkill(existingId, remoteName, decl, files, apiMode);
       } else {
         const manifestName = skillNameFromFiles(files);
         const searchNames = manifestName && manifestName !== remoteName ? [remoteName, manifestName] : [remoteName];
-        const existing = await findExistingByNames(provider, "skill", searchNames);
+        const existing = await findExistingByNames(provider, "skill", searchNames, apiMode);
         if (existing) {
           result = existing.resource;
           emitRuntimeFeedback(ctx.onFeedback, {
@@ -6499,9 +6752,10 @@ async function executeActionInner(action, provider, ctx) {
           adopted = true;
         } else {
           try {
-            result = await provider.createSkill(remoteName, decl, files);
+            result = await provider.createSkill(remoteName, decl, files, apiMode);
           } catch (err) {
             result = await adoptOnConflict(err, address, provider, ctx.onFeedback, {
+              mode: apiMode,
               searchNames,
               onExisting: async (existing2) => existing2
             });
@@ -6520,15 +6774,19 @@ async function executeActionInner(action, provider, ctx) {
         throw memoryStoreUnsupported(address.provider);
       }
       const reconcile = async (storeId) => {
-        const store = await provider.updateMemoryStore(storeId, {
-          name,
-          description: decl.description,
-          metadata: decl.metadata ?? {}
-        });
+        const store = await provider.updateMemoryStore(
+          storeId,
+          {
+            name,
+            description: decl.description,
+            metadata: decl.metadata ?? {}
+          },
+          apiMode
+        );
         const current = /* @__PURE__ */ new Map();
         let cursor;
         do {
-          const page2 = await provider.listMemories(storeId, { limit: 100, cursor, view: "basic" });
+          const page2 = await provider.listMemories(storeId, { limit: 100, cursor, view: "basic" }, apiMode);
           for (const memory of page2.data) {
             if (memory.type === "memory") current.set(memory.path, memory);
           }
@@ -6538,24 +6796,33 @@ async function executeActionInner(action, provider, ctx) {
           const existing = current.get(entry.key.replace(/^\/+/, ""));
           if (existing) {
             if (existing.content_sha256 !== sha256(entry.content)) {
-              await provider.updateMemory(storeId, existing.id, {
-                content: entry.content,
-                expected_content_sha256: existing.content_sha256
-              });
+              await provider.updateMemory(
+                storeId,
+                existing.id,
+                {
+                  content: entry.content,
+                  expected_content_sha256: existing.content_sha256
+                },
+                apiMode
+              );
             }
           } else {
-            await provider.createMemory(storeId, { path: entry.key, content: entry.content });
+            await provider.createMemory(storeId, { path: entry.key, content: entry.content }, apiMode);
           }
         }
         return store;
       };
-      if (isUpdate) {
+      if (apiModeChanged) {
+        result = await createMemoryStore2(name, decl, apiMode);
+        if (existingId) await deleteMemoryStore2(existingId, priorApiMode).catch(() => void 0);
+      } else if (isUpdate) {
         result = await reconcile(existingId);
       } else {
         try {
-          result = await createMemoryStore2(name, decl);
+          result = await createMemoryStore2(name, decl, apiMode);
         } catch (err) {
           result = await adoptOnConflict(err, address, provider, ctx.onFeedback, {
+            mode: apiMode,
             onExisting: async (existing) => reconcile(existing.id)
           });
           adopted = true;
@@ -6705,15 +6972,12 @@ async function executeActionInner(action, provider, ctx) {
         const oldId = ctx.state.getResource(address)?.remote_id;
         if (oldId) {
           try {
-            await provider.deleteFile(oldId);
+            await provider.deleteFile(oldId, priorApiMode);
           } catch {
           }
         }
       }
-      const info = await provider.uploadFile(filePath, {
-        name: decl.name,
-        purpose: decl.purpose
-      });
+      const info = await provider.uploadFile(filePath, { name: decl.name, purpose: decl.purpose }, apiMode);
       result = { id: info.id, type: "file" };
       break;
     }
@@ -6734,6 +6998,7 @@ async function executeActionInner(action, provider, ctx) {
     address,
     remote_id: result.id,
     externally_managed: priorResource?.externally_managed || type === "environment" && ctx.config.environments?.[name]?.environment_id || type === "identity" && ctx.config.identities?.[name]?.identity_id ? true : void 0,
+    api_mode: apiMode,
     version: result.version,
     content_hash: hash,
     desired_hash: hash,
@@ -6748,9 +7013,37 @@ async function executeActionInner(action, provider, ctx) {
   if (action.previousAddress) ctx.state.removeResource(action.previousAddress);
   return adopted;
 }
-async function findExistingByNames(provider, type, names) {
+function ownedForwardMemoryStoreIds(ctx, provider) {
+  return ctx.state.listResources().filter(
+    (resource) => resource.address.provider === provider && resource.address.type === "memory_store" && resource.api_mode === "forward" && typeof resource.remote_id === "string"
+  ).map((resource) => resource.remote_id);
+}
+function resolveResourceApiMode(type, name, provider, config) {
+  if (provider !== "qoder" || type !== "environment" && type !== "skill" && type !== "vault" && type !== "memory_store" && type !== "file") {
+    return void 0;
+  }
+  if (type === "environment" && config.environments?.[name]?.environment_id) return "auto";
+  let managed = false;
+  let forward = false;
+  for (const agent of Object.values(config.agents ?? {})) {
+    if (agent.provider && agent.provider !== provider) continue;
+    const referenced = type === "environment" ? agent.environment === name : type === "skill" ? agent.skills?.some(
+      (skill) => typeof skill === "string" ? skill === name : skill.type === "custom" && skill.skill_id === name
+    ) : type === "vault" ? agent.vault === name : type === "memory_store" ? agent.memory_stores?.includes(name) : agent.files?.includes(name);
+    if (!referenced) continue;
+    if (agent.delivery?.qoder?.type === "forward") forward = true;
+    else managed = true;
+  }
+  if (managed && forward) {
+    throw new UserError(
+      `Qoder ${type}.${name} is referenced by both Managed and Forward agents; declare separate resources for each API domain.`
+    );
+  }
+  return forward ? "forward" : "managed";
+}
+async function findExistingByNames(provider, type, names, mode) {
   for (const candidate of names) {
-    const found = await provider.findResource(type, candidate);
+    const found = await provider.findResource(type, candidate, void 0, mode);
     if (found && found.id !== null) return { resource: found, name: candidate };
   }
   return null;
@@ -6758,7 +7051,7 @@ async function findExistingByNames(provider, type, names) {
 async function adoptOnConflict(err, address, provider, onFeedback, opts) {
   if (!(err instanceof ConflictError)) throw err;
   const candidates = opts.searchNames?.length ? opts.searchNames : [address.name];
-  const existing = await findExistingByNames(provider, address.type, candidates);
+  const existing = await findExistingByNames(provider, address.type, candidates, opts.mode);
   if (!existing) throw nameReservedError(err, address, candidates.join('" / "'));
   emitRuntimeFeedback(onFeedback, {
     type: "resource_adopted",
@@ -6847,6 +7140,13 @@ function agentTargetsProvider(config, agentProvider, providerName) {
   return Object.hasOwn(config.providers, providerName);
 }
 
+// src/internal/core/agent-materialization.ts
+function resolveAgentMaterialization(provider, agent) {
+  const mode = agent.delivery?.[provider]?.type ?? "managed";
+  if (mode === "managed") return { resourceType: "agent", mode };
+  return { resourceType: "template", mode };
+}
+
 // src/internal/core/validate-config.ts
 function validateProjectConfig(config, options = {}) {
   const collector = new DiagnosticCollector();
@@ -6873,6 +7173,7 @@ function collectReferenceDiagnostics(config, diagnostics) {
   const skillNames = new Set(Object.keys(config.skills ?? {}));
   const vaultNames = new Set(Object.keys(config.vaults ?? {}));
   const memoryNames = new Set(Object.keys(config.memory_stores ?? {}));
+  const fileNames = new Set(Object.keys(config.files ?? {}));
   const agentNames = new Set(Object.keys(config.agents ?? {}));
   const identityNames = new Set(Object.keys(config.identities ?? {}));
   if (config.defaults?.identity && !identityNames.has(config.defaults.identity)) {
@@ -6900,6 +7201,11 @@ function collectReferenceDiagnostics(config, diagnostics) {
     if (agent.vault && !vaultNames.has(agent.vault)) {
       diagnostics.error("config.agent.vault.unknown", `agent.${name}: references unknown vault '${agent.vault}'`);
     }
+    for (const file of agent.files ?? []) {
+      if (!fileNames.has(file)) {
+        diagnostics.error("config.agent.file.unknown", `agent.${name}: references unknown file '${file}'`);
+      }
+    }
     for (const memory of agent.memory_stores ?? []) {
       if (!memoryNames.has(memory)) {
         diagnostics.error(
@@ -6931,7 +7237,10 @@ function collectReferenceDiagnostics(config, diagnostics) {
     }
   }
   for (const [name, channel] of Object.entries(config.channels ?? {})) {
-    if (!agentNames.has(channel.agent)) {
+    if (channel.mode === "pairing") continue;
+    if (!channel.agent) {
+      diagnostics.error("config.channel.agent.required", `channel.${name}: fixed-mode channels require agent`);
+    } else if (!agentNames.has(channel.agent)) {
       diagnostics.error("config.channel.agent.unknown", `channel.${name}: references unknown agent '${channel.agent}'`);
     }
     const identity = channel.identity ?? config.defaults?.identity;
@@ -7011,29 +7320,31 @@ function collectProviderCapabilities(config, providers, diagnostics) {
         continue;
       }
       if (providerName === "qoder") {
-        const agent = config.agents?.[channel.agent];
-        if (agent?.provider && agent.provider !== providerName) {
-          diagnostics.error(
-            "config.channel.agent.provider_mismatch",
-            `channel.${name}: agent '${channel.agent}' is pinned to provider '${agent.provider}'.`,
-            { type: "channel", name, provider: providerName }
-          );
-        }
-        const identityName = channel.identity ?? config.defaults?.identity;
-        const identity = identityName ? config.identities?.[identityName] : void 0;
-        if (identity?.provider && identity.provider !== providerName) {
-          diagnostics.error(
-            "config.channel.identity.provider_mismatch",
-            `channel.${name}: identity '${identityName}' is pinned to provider '${identity.provider}'.`,
-            { type: "channel", name, provider: providerName }
-          );
-        }
-        if (agent && agent.delivery?.qoder?.type !== "forward") {
-          diagnostics.error(
-            "qoder.channel.forward_template.required",
-            `channel.${name}: Qoder Channels require agent '${channel.agent}' to use delivery.qoder.type: forward.`,
-            { type: "channel", name, provider: providerName }
-          );
+        if (channel.mode !== "pairing" && channel.agent) {
+          const agent = config.agents?.[channel.agent];
+          if (agent?.provider && agent.provider !== providerName) {
+            diagnostics.error(
+              "config.channel.agent.provider_mismatch",
+              `channel.${name}: agent '${channel.agent}' is pinned to provider '${agent.provider}'.`,
+              { type: "channel", name, provider: providerName }
+            );
+          }
+          const identityName = channel.identity ?? config.defaults?.identity;
+          const identity = identityName ? config.identities?.[identityName] : void 0;
+          if (identity?.provider && identity.provider !== providerName) {
+            diagnostics.error(
+              "config.channel.identity.provider_mismatch",
+              `channel.${name}: identity '${identityName}' is pinned to provider '${identity.provider}'.`,
+              { type: "channel", name, provider: providerName }
+            );
+          }
+          if (agent && agent.delivery?.qoder?.type !== "forward") {
+            diagnostics.error(
+              "qoder.channel.forward_template.required",
+              `channel.${name}: Qoder Channels require agent '${channel.agent}' to use delivery.qoder.type: forward.`,
+              { type: "channel", name, provider: providerName }
+            );
+          }
         }
         const requiredCredentials = {
           dingtalk: ["client_id", "client_secret"],
@@ -7064,6 +7375,46 @@ function collectProviderCapabilities(config, providers, diagnostics) {
         }
       }
     }
+    if (providerName === "qoder") {
+      const domains = /* @__PURE__ */ new Map();
+      for (const agent of Object.values(config.agents ?? {})) {
+        if (agent.provider && agent.provider !== providerName) continue;
+        const mode = agent.delivery?.qoder?.type === "forward" ? "forward" : "managed";
+        const refs = [
+          ...agent.environment && !config.environments?.[agent.environment]?.environment_id ? [`environment:${agent.environment}`] : [],
+          ...(agent.skills ?? []).flatMap(
+            (skill) => typeof skill === "string" ? [`skill:${skill}`] : skill.type === "custom" ? [`skill:${skill.skill_id}`] : []
+          ),
+          ...agent.vault ? [`vault:${agent.vault}`] : [],
+          ...(agent.memory_stores ?? []).map((store) => `memory_store:${store}`),
+          ...(agent.files ?? []).map((file) => `file:${file}`)
+        ];
+        for (const ref of refs) {
+          const modes = domains.get(ref) ?? /* @__PURE__ */ new Set();
+          modes.add(mode);
+          domains.set(ref, modes);
+        }
+      }
+      for (const [ref, modes] of domains) {
+        if (modes.size < 2) continue;
+        const [type, name] = ref.split(":");
+        diagnostics.error(
+          `qoder.${type}.delivery_domain.conflict`,
+          `${type}.${name}: referenced by both Managed and Forward agents; declare separate resources because Qoder uses different API domains.`,
+          { type, name, provider: providerName }
+        );
+      }
+    }
+    for (const [name, agent] of Object.entries(config.agents ?? {})) {
+      if (agent.provider && agent.provider !== providerName) continue;
+      if (agent.files?.length && (providerName !== "qoder" || agent.delivery?.qoder?.type !== "forward")) {
+        diagnostics.error(
+          "config.agent.files.unsupported",
+          `agent.${name}: files are supported only by Qoder Forward Templates.`,
+          { type: resolveAgentMaterialization(providerName, agent).resourceType, name, provider: providerName }
+        );
+      }
+    }
     for (const [name, agent] of Object.entries(config.agents ?? {})) {
       if (agent.provider && agent.provider !== providerName) continue;
       const delivery = agent.delivery?.[providerName]?.type ?? "managed";
@@ -7104,6 +7455,44 @@ function collectProviderCapabilities(config, providers, diagnostics) {
           address
         );
       }
+      if (delivery !== "forward" && agent.managed_tool_config) {
+        diagnostics.error(
+          `${providerName}.agent.managed_tool_config.forward_required`,
+          `agent.${name}: managed_tool_config applies to Forward Templates; set delivery.${providerName}.type: forward or remove it.`,
+          address
+        );
+      }
+      if (agent.default_memory_store) {
+        if (providerName !== "qoder" || delivery !== "forward") {
+          diagnostics.error(
+            `${providerName}.agent.default_memory_store.forward_required`,
+            `agent.${name}: default_memory_store is supported only by Qoder Forward delivery.`,
+            address
+          );
+        } else if (!config.defaults?.identity) {
+          diagnostics.error(
+            "qoder.template.default_memory_store.identity.required",
+            `agent.${name}: default_memory_store requires defaults.identity to select the owning Forward Identity.`,
+            { type: "template", name, provider: providerName }
+          );
+        } else {
+          const identity = config.identities?.[config.defaults.identity];
+          if (identity?.provider && identity.provider !== providerName) {
+            diagnostics.error(
+              "qoder.template.default_memory_store.identity.provider_mismatch",
+              `agent.${name}: defaults.identity '${config.defaults.identity}' is pinned to provider '${identity.provider}'.`,
+              { type: "template", name, provider: providerName }
+            );
+          }
+          if (agent.default_memory_store.delete_on_destroy && identity?.identity_id) {
+            diagnostics.error(
+              "qoder.template.default_memory_store.delete.external_identity",
+              `agent.${name}: delete_on_destroy requires an OpenCMA-managed Identity because an external Identity keeps the default Memory Store mounted.`,
+              { type: "template", name, provider: providerName }
+            );
+          }
+        }
+      }
       if (delivery === "forward" && !isSupported(caps, "template")) {
         diagnostics.error(
           `${providerName}.agent.delivery.forward.unsupported`,
@@ -7119,10 +7508,10 @@ function collectProviderCapabilities(config, providers, diagnostics) {
             { type: "template", name, provider: providerName }
           );
         }
-        if (agent.memory_stores?.length) {
+        if (agent.memory_stores?.length && !config.defaults?.identity) {
           diagnostics.error(
-            "qoder.template.memory_store.unsupported",
-            `agent.${name}: memory_stores are not yet supported by Qoder Forward Template delivery.`,
+            "qoder.template.memory_store.identity.required",
+            `agent.${name}: Forward memory_stores require defaults.identity for the Identity/Template mount.`,
             { type: "template", name, provider: providerName }
           );
         }
@@ -7237,6 +7626,13 @@ function collectProviderCapabilities(config, providers, diagnostics) {
             { type: "agent", name, provider: providerName }
           );
         }
+        if (agent.managed_tool_config && (!agent.provider || agent.provider === providerName)) {
+          diagnostics.error(
+            `${providerName}.agent.managed_tool_config.unsupported`,
+            `agent.${name}: managed_tool_config is supported only by Qoder; remove it or pin this agent to qoder.`,
+            { type: "agent", name, provider: providerName }
+          );
+        }
         if (agent.tunnel && (!agent.provider || agent.provider === providerName)) {
           diagnostics.error(
             `${providerName}.agent.tunnel.unsupported`,
@@ -7335,13 +7731,6 @@ function collectProviderCapabilities(config, providers, diagnostics) {
   }
 }
 
-// src/internal/core/agent-materialization.ts
-function resolveAgentMaterialization(provider, agent) {
-  const mode = agent.delivery?.[provider]?.type ?? "managed";
-  if (mode === "managed") return { resourceType: "agent", mode };
-  return { resourceType: "template", mode };
-}
-
 // src/internal/graph/dependency.ts
 function buildDependencyGraph(config, targetProviders) {
   const nodes = /* @__PURE__ */ new Map();
@@ -7409,6 +7798,13 @@ function buildDependencyGraph(config, targetProviders) {
         const materialization = resolveAgentMaterialization(provider, decl);
         const agentAddr = { type: materialization.resourceType, name, provider };
         addNode(agentAddr);
+        if ((decl.default_memory_store || decl.memory_stores?.length) && materialization.resourceType === "template") {
+          const identityName = config.defaults?.identity;
+          if (identityName) {
+            const identityAddr = { type: "identity", name: identityName, provider };
+            if (nodes.has(addressKey(identityAddr))) addEdge(agentAddr, identityAddr);
+          }
+        }
         if (decl.environment && config.environments?.[decl.environment]) {
           const envAddr = {
             type: "environment",
@@ -7435,6 +7831,12 @@ function buildDependencyGraph(config, targetProviders) {
             addEdge(agentAddr, vaultAddr);
           }
         }
+        if (decl.files) {
+          for (const fileName of decl.files) {
+            const fileAddr = { type: "file", name: fileName, provider };
+            if (nodes.has(addressKey(fileAddr))) addEdge(agentAddr, fileAddr);
+          }
+        }
         if (decl.memory_stores) {
           for (const msName of decl.memory_stores) {
             const msAddr = {
@@ -7499,6 +7901,7 @@ function buildDependencyGraph(config, targetProviders) {
         if (decl.provider && decl.provider !== provider) continue;
         const channelAddr = { type: "channel", name, provider };
         addNode(channelAddr);
+        if (decl.mode === "pairing" || !decl.agent) continue;
         const agentDecl = config.agents?.[decl.agent];
         const agentType = agentDecl ? resolveAgentMaterialization(provider, agentDecl).resourceType : "agent";
         const agentAddr = { type: agentType, name: decl.agent, provider };
@@ -7839,7 +8242,7 @@ async function refreshState(state, providers, options = {}) {
         dirty = true;
         continue;
       }
-      const remote = await provider.findResource(res.address.type, res.address.name, res.remote_id);
+      const remote = await provider.findResource(res.address.type, res.address.name, res.remote_id, res.api_mode);
       if (!remote) {
         if (!options.quiet) {
           emitRuntimeFeedback(options.onFeedback, {
@@ -8397,12 +8800,61 @@ function planDestroyProjectContext(ctx) {
   const resources = [...ctx.state.listResources()].sort(
     (a, b) => (destroyOrder[a.address.type] ?? 99) - (destroyOrder[b.address.type] ?? 99)
   );
-  return { resources, executionContext: ctx };
+  const identityName = ctx.config.defaults?.identity;
+  const defaultMemoryStores = [];
+  for (const [agentName, agent] of Object.entries(ctx.config.agents ?? {})) {
+    if (!agent.default_memory_store || agent.delivery?.qoder?.type !== "forward") continue;
+    if (agent.provider && agent.provider !== "qoder") continue;
+    defaultMemoryStores.push({
+      agentName,
+      provider: "qoder",
+      identityId: identityName ? ctx.state.getResource({ type: "identity", name: identityName, provider: "qoder" })?.remote_id ?? null : null,
+      templateId: ctx.state.getResource({ type: "template", name: agentName, provider: "qoder" })?.remote_id ?? null,
+      deleteOnDestroy: agent.default_memory_store.delete_on_destroy ?? false
+    });
+  }
+  for (const pending of ctx.state.getStateFile().pending_default_memory_store_cleanups ?? []) {
+    const existing = defaultMemoryStores.find(
+      (item) => item.agentName === pending.agent_name && item.provider === pending.provider
+    );
+    if (existing) {
+      existing.memoryStoreId = pending.remote_id;
+      existing.deleteOnDestroy = true;
+    } else {
+      defaultMemoryStores.push({
+        agentName: pending.agent_name,
+        provider: pending.provider,
+        identityId: pending.identity_id ?? null,
+        templateId: pending.template_id ?? null,
+        deleteOnDestroy: true,
+        memoryStoreId: pending.remote_id
+      });
+    }
+  }
+  return { resources, defaultMemoryStores, executionContext: ctx };
 }
 async function destroyPlannedProjectResources(planned, options = {}) {
   const results = [];
-  let stateChanged = false;
+  const capturedDefaults = await captureDefaultMemoryStores(planned);
   const ctx = planned.executionContext;
+  if (capturedDefaults.some((item) => item.error)) {
+    const defaultMemoryStoreResults2 = capturedDefaults.map(preflightFailureResult);
+    for (const resource of planned.resources) {
+      const result = {
+        resource,
+        status: "blocked",
+        reason: "skipped",
+        error: "Destroy aborted because the default Memory Store preflight failed."
+      };
+      results.push(result);
+      options.onResourceResult?.(result);
+    }
+    return { ...planned, results, defaultMemoryStoreResults: defaultMemoryStoreResults2, destroyed: 0, partial: true };
+  }
+  if (await persistCapturedDefaultMemoryStores(ctx, capturedDefaults)) {
+    await ctx.state.save();
+  }
+  let stateChanged = false;
   for (const resource of planned.resources) {
     options.onResourceStart?.(resource);
     const result = await destroyOneResource(ctx, resource, options);
@@ -8413,14 +8865,171 @@ async function destroyPlannedProjectResources(planned, options = {}) {
   if (stateChanged) {
     await ctx.state.save();
   }
+  const defaultMemoryStoreResults = await finalizeDefaultMemoryStores(planned, capturedDefaults, options);
+  if (recordFailedDefaultMemoryStoreCleanups(ctx, defaultMemoryStoreResults)) {
+    await ctx.state.save();
+  }
+  if (clearCompletedDefaultMemoryStoreCleanups(ctx, defaultMemoryStoreResults)) {
+    await ctx.state.save();
+  }
   const destroyed = results.filter((result) => result.status === "success").length;
   return {
     ...planned,
     results,
+    defaultMemoryStoreResults,
     destroyed,
-    partial: destroyed !== planned.resources.length
+    partial: destroyed !== planned.resources.length || defaultMemoryStoreResults.some((result) => result.status === "failed")
+  };
+}
+async function persistCapturedDefaultMemoryStores(ctx, captured) {
+  const state = ctx.state.getStateFile();
+  if (!state.pending_default_memory_store_cleanups) state.pending_default_memory_store_cleanups = [];
+  const pending = state.pending_default_memory_store_cleanups;
+  let changed = false;
+  for (const item of captured) {
+    if (!item.plan.deleteOnDestroy || !item.memoryStoreId) continue;
+    if (pending.some((entry) => entry.provider === item.plan.provider && entry.remote_id === item.memoryStoreId))
+      continue;
+    pending.push({
+      agent_name: item.plan.agentName,
+      provider: item.plan.provider,
+      remote_id: item.memoryStoreId,
+      ...item.plan.identityId ? { identity_id: item.plan.identityId } : {},
+      ...item.plan.templateId ? { template_id: item.plan.templateId } : {}
+    });
+    changed = true;
+  }
+  return changed;
+}
+function clearCompletedDefaultMemoryStoreCleanups(ctx, results) {
+  const state = ctx.state.getStateFile();
+  const completedIds = new Set(
+    results.filter((item) => item.status === "deleted" || item.status === "already_gone").map((item) => item.memoryStoreId).filter((id) => Boolean(id))
+  );
+  if (completedIds.size === 0 || !state.pending_default_memory_store_cleanups?.length) return false;
+  const remaining = state.pending_default_memory_store_cleanups.filter((item) => !completedIds.has(item.remote_id));
+  if (remaining.length === state.pending_default_memory_store_cleanups.length) return false;
+  state.pending_default_memory_store_cleanups = remaining;
+  return true;
+}
+function recordFailedDefaultMemoryStoreCleanups(ctx, results) {
+  const pending = ctx.state.getStateFile().pending_default_memory_store_cleanups;
+  if (!pending?.length) return false;
+  let changed = false;
+  for (const result of results) {
+    if (result.status !== "failed" || !result.memoryStoreId) continue;
+    const entry = pending.find((item) => item.remote_id === result.memoryStoreId);
+    if (entry && entry.last_error !== result.error) {
+      entry.last_error = result.error;
+      changed = true;
+    }
+  }
+  return changed;
+}
+function preflightFailureResult(item) {
+  if (!item.plan.deleteOnDestroy) return { ...item.plan, status: "retained" };
+  return {
+    ...item.plan,
+    status: "failed",
+    ...item.memoryStoreId ? { memoryStoreId: item.memoryStoreId } : {},
+    error: item.error ?? "Destroy aborted because another default Memory Store preflight failed."
   };
 }
+async function captureDefaultMemoryStores(planned) {
+  return Promise.all(
+    planned.defaultMemoryStores.map(async (item) => {
+      if (!item.deleteOnDestroy) return { plan: item };
+      if (item.memoryStoreId) return { plan: item, memoryStoreId: item.memoryStoreId };
+      if (!item.identityId || !item.templateId) {
+        return { plan: item, error: "Cannot resolve the Identity and Template before destroy." };
+      }
+      try {
+        const provider = getRuntimeProvider(planned.executionContext, item.provider);
+        if (!provider.findDefaultMemoryStoreId || !provider.deleteDefaultMemoryStore) {
+          return { plan: item, error: `Provider '${item.provider}' cannot delete a default memory store.` };
+        }
+        const memoryStoreId = await provider.findDefaultMemoryStoreId(item.identityId, item.templateId);
+        return { plan: item, ...memoryStoreId ? { memoryStoreId } : {} };
+      } catch (error) {
+        return { plan: item, error: error instanceof Error ? error.message : String(error) };
+      }
+    })
+  );
+}
+async function finalizeDefaultMemoryStores(planned, captured, options) {
+  const output = [];
+  for (const item of captured) {
+    if (!item.plan.deleteOnDestroy) {
+      output.push({ ...item.plan, status: "retained" });
+      continue;
+    }
+    if (item.error) {
+      output.push({ ...item.plan, status: "failed", error: item.error });
+      continue;
+    }
+    if (!item.memoryStoreId) {
+      output.push({ ...item.plan, status: "already_gone" });
+      continue;
+    }
+    try {
+      const provider = getRuntimeProvider(planned.executionContext, item.plan.provider);
+      await deleteDefaultMemoryStoreWithArchiveFallback(
+        provider,
+        item.memoryStoreId,
+        options.defaultMemoryStoreRetryDelaysMs ?? [1e3, 2e3, 4e3, 8e3]
+      );
+      output.push({ ...item.plan, status: "deleted", memoryStoreId: item.memoryStoreId });
+    } catch (error) {
+      if (ApiError.isNotFound(error)) {
+        output.push({ ...item.plan, status: "already_gone", memoryStoreId: item.memoryStoreId });
+      } else {
+        output.push({
+          ...item.plan,
+          status: "failed",
+          memoryStoreId: item.memoryStoreId,
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+  }
+  return output;
+}
+async function deleteDefaultMemoryStoreWithArchiveFallback(provider, memoryStoreId, retryDelaysMs) {
+  try {
+    await retryDefaultMemoryStoreOperation(() => provider.deleteDefaultMemoryStore(memoryStoreId), retryDelaysMs);
+  } catch (error) {
+    if (isAlreadyArchivedConflict(error) && provider.deleteMemoryStore) {
+      await retryDefaultMemoryStoreOperation(() => provider.deleteMemoryStore(memoryStoreId), retryDelaysMs);
+      return;
+    }
+    if (!isStillMountedConflict(error) || !provider.archiveMemoryStore || !provider.deleteMemoryStore) throw error;
+    await retryDefaultMemoryStoreOperation(() => provider.archiveMemoryStore(memoryStoreId), retryDelaysMs);
+    await retryDefaultMemoryStoreOperation(() => provider.deleteMemoryStore(memoryStoreId), retryDelaysMs);
+  }
+}
+async function retryDefaultMemoryStoreOperation(operation, delaysMs) {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      await operation();
+      return;
+    } catch (error) {
+      if (!isRetryableDefaultMemoryStoreError(error) || attempt >= delaysMs.length) throw error;
+      await delay(delaysMs[attempt]);
+    }
+  }
+}
+function isRetryableDefaultMemoryStoreError(error) {
+  return error instanceof ApiError && (isStillMountedConflict(error) || isAlreadyArchivedConflict(error) || error.statusCode === 429 || [500, 502, 503].includes(error.statusCode));
+}
+function isStillMountedConflict(error) {
+  return error instanceof ApiError && error.statusCode === 409 && error.responseBody.includes("still mounted");
+}
+function isAlreadyArchivedConflict(error) {
+  return error instanceof ApiError && error.statusCode === 409 && error.responseBody.toLowerCase().includes("already archived");
+}
+function delay(ms) {
+  return new Promise((resolve13) => setTimeout(resolve13, ms));
+}
 async function destroyOneResource(ctx, resource, options) {
   if (isExternalReference(ctx, resource)) {
     ctx.state.removeResource(resource.address);
@@ -8441,8 +9050,18 @@ async function destroyOneResource(ctx, resource, options) {
     ctx.state.removeResource(resource.address);
     return successResult(resource, "destroyed");
   }
+  const apiMode = resource.api_mode === "auto" ? void 0 : resource.api_mode;
   try {
-    await deleteRemoteResource(provider, resource.address.type, resource.remote_id, options.cascade);
+    await deleteRemoteResource(
+      provider,
+      resource.address.type,
+      resource.remote_id,
+      options.cascade,
+      apiMode,
+      ctx.state.listResources().filter(
+        (candidate) => candidate.address.provider === resource.address.provider && candidate.address.type === "memory_store" && candidate.api_mode === "forward" && typeof candidate.remote_id === "string"
+      ).map((candidate) => candidate.remote_id)
+    );
     ctx.state.removeResource(resource.address);
     emitRuntimeFeedback(options.onFeedback, {
       type: "resource_action_success",
@@ -8471,7 +9090,7 @@ async function destroyOneResource(ctx, resource, options) {
       };
       if (await options.onCascadeRequired?.(blocked)) {
         try {
-          await provider.deleteEnvironment(resource.remote_id, true);
+          await provider.deleteEnvironment(resource.remote_id, true, apiMode);
           ctx.state.removeResource(resource.address);
           return {
             ...successResult(resource, "destroyed"),
@@ -8507,29 +9126,29 @@ function failureResult(resource, error) {
     error: error instanceof Error ? error.message : String(error)
   };
 }
-async function deleteRemoteResource(provider, type, id, cascade) {
+async function deleteRemoteResource(provider, type, id, cascade, mode, ownedMemoryStoreIds = []) {
   switch (type) {
     case "agent":
       await provider.deleteAgent(id);
       return;
     case "template":
       if (!provider.archiveTemplate) throw new UserError(`Provider does not support templates`);
-      await provider.archiveTemplate(id);
+      await provider.archiveTemplate(id, ownedMemoryStoreIds);
       return;
     case "skill":
-      await provider.deleteSkill(id);
+      await provider.deleteSkill(id, mode);
       return;
     case "memory_store":
       if (!provider.deleteMemoryStore) {
         throw new UserError(`Provider does not support memory stores`);
       }
-      await provider.deleteMemoryStore(id);
+      await provider.deleteMemoryStore(id, mode);
       return;
     case "vault":
-      await provider.deleteVault(id);
+      await provider.deleteVault(id, mode);
       return;
     case "environment":
-      await provider.deleteEnvironment(id, cascade);
+      await provider.deleteEnvironment(id, cascade, mode);
       return;
     case "deployment":
       await provider.deleteDeployment(id);
@@ -8543,7 +9162,7 @@ async function deleteRemoteResource(provider, type, id, cascade) {
       await provider.deleteChannel(id);
       return;
     case "file":
-      await provider.deleteFile(id);
+      await provider.deleteFile(id, mode);
       return;
   }
 }
@@ -9308,7 +9927,7 @@ async function collectEventsUntilTerminal(adapter2, sessionId, options = {}) {
         terminalStatus = terminalEvent.status;
         break;
       }
-      await delay(currentIntervalMs);
+      await delay2(currentIntervalMs);
       currentIntervalMs = Math.min(currentIntervalMs * 2, maxPollIntervalMs);
     }
   } else {
@@ -9319,7 +9938,7 @@ async function collectEventsUntilTerminal(adapter2, sessionId, options = {}) {
         terminalStatus = session.status;
         break;
       }
-      await delay(currentIntervalMs);
+      await delay2(currentIntervalMs);
       currentIntervalMs = Math.min(currentIntervalMs * 2, maxPollIntervalMs);
     }
     result = await adapter2.listSessionEvents(sessionId, { limit: 100 });
@@ -9486,7 +10105,7 @@ async function* streamWithResume(adapter2, sessionId, message) {
       }
     }
     if (!reachedTerminal) {
-      await delay(reconnectIntervalMs);
+      await delay2(reconnectIntervalMs);
       reconnectIntervalMs = Math.min(reconnectIntervalMs * 2, DEFAULT_POLL_INTERVAL_MS);
     }
   }
@@ -9514,7 +10133,7 @@ function assertNotTimedOut(start, timeoutMs) {
     throw new UserError(`Session did not complete within the timeout (${Math.floor(timeoutMs / 1e3)} seconds).`);
   }
 }
-function delay(ms) {
+function delay2(ms) {
   return new Promise((resolve13) => setTimeout(resolve13, ms));
 }
 
@@ -9700,6 +10319,7 @@ var StateManager = class _StateManager {
         address: r.address,
         remote_id: r.remote_id,
         externally_managed: r.externally_managed === true ? true : void 0,
+        api_mode: r.api_mode === "forward" ? "forward" : r.api_mode === "managed" ? "managed" : void 0,
         version: r.version,
         content_hash: r.content_hash ?? r.desired_hash ?? "",
         desired_hash: r.desired_hash ?? r.content_hash ?? "",
@@ -9711,7 +10331,11 @@ var StateManager = class _StateManager {
         drift_paths: r.drift_paths,
         drift_status: r.drift_status
       }));
-      return new _StateManager({ resources }, path);
+      const pending = Array.isArray(data.pending_default_memory_store_cleanups) ? data.pending_default_memory_store_cleanups : void 0;
+      return new _StateManager(
+        { resources, ...pending ? { pending_default_memory_store_cleanups: pending } : {} },
+        path
+      );
     } catch (err) {
       if (err && typeof err === "object" && "code" in err && err.code === "ENOENT") {
         return _StateManager.initialize(path);