@autohq/cli 0.1.149 → 0.1.151

package/dist/index.js

@@ -18510,8 +18510,8 @@ function isSafePathUnderHome(value, home) {
   if (!value.startsWith(prefix)) {
     return false;
   }
-  const relative = value.slice(prefix.length);
-  return relative.split("/").every((segment) => segment !== "" && segment !== "." && segment !== "..");
+  const relative2 = value.slice(prefix.length);
+  return relative2.split("/").every((segment) => segment !== "" && segment !== "." && segment !== "..");
 }
 function isSafeRelativePath(value) {
   if (!value || value.startsWith("/")) {
@@ -21306,7 +21306,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@autohq/cli",
-      version: "0.1.149",
+      version: "0.1.151",
       license: "SEE LICENSE IN README.md",
       publishConfig: {
         access: "public"
@@ -21403,28 +21403,6 @@ function compileAgentFile(path2) {
     removals: context.removals
   };
 }
-function compileAgentDocumentValue(document, path2) {
-  const context = { graph: /* @__PURE__ */ new Map(), removals: [] };
-  const compiled = finalizeAgentApplyShape(
-    compileAgentDocument(document, path2, [], context),
-    path2
-  );
-  const parsed = ProjectApplyResourceSchema.safeParse(compiled.resource);
-  if (!parsed.success) {
-    throw new Error(`Invalid compiled agent ${path2}: ${parsed.error.message}`);
-  }
-  if (parsed.data.kind !== RESOURCE_KIND_AGENT) {
-    throw new Error(
-      `Invalid compiled agent ${path2}: expected kind "agent", got "${parsed.data.kind}"`
-    );
-  }
-  return {
-    resource: parsed.data,
-    resources: [...compiled.resources, parsed.data],
-    graph: [...context.graph.values()],
-    removals: context.removals
-  };
-}
 function renderCompiledAgentYaml(result) {
   return stringify(result.resource).trimEnd();
 }
@@ -21481,9 +21459,6 @@ function readLocalAgentAuthoringStatuses(input) {
     }
   });
 }
-function validateAgentFragmentFile(path2) {
-  validateAgentFragmentDocument(readSingleDocument(path2), path2, []);
-}
 function agentAuthoringFiles(directory) {
   let entries;
   try {
@@ -21566,29 +21541,6 @@ function compileAgentDocument(document, path2, stack, context) {
     []
   );
 }
-function validateAgentFragmentDocument(document, path2, stack) {
-  const resolvedPath = resolve(path2);
-  if (stack.includes(resolvedPath)) {
-    throw new Error(
-      `Agent import cycle detected: ${[...stack, resolvedPath].join(" -> ")}`
-    );
-  }
-  if (!isRecord(document)) {
-    throw new Error(`Invalid agent fragment file ${path2}: expected object`);
-  }
-  for (const imported of importPaths(document).map(
-    (importPath) => resolveImportPath(importPath, resolvedPath)
-  )) {
-    validateAgentFragmentDocument(readSingleDocument(imported), imported, [
-      ...stack,
-      resolvedPath
-    ]);
-  }
-  for (const removal of removalDirectives(document, resolvedPath)) {
-    assertSupportedRemovalTarget(removal.target);
-  }
-  authoringDocumentApplyShape(document, resolvedPath);
-}
 function readSingleDocument(path2) {
   const documents = readDocuments(path2);
   if (documents.length !== 1) {
@@ -22298,112 +22250,201 @@ var init_assets = __esm({
   }
 });
 
-// src/commands/apply/files.ts
-import { createHash as createHash3 } from "crypto";
-import {
-  readFileSync as readFileSync4,
-  readdirSync as readdirSync3,
-  realpathSync,
-  statSync as statSync2
-} from "fs";
-import {
-  basename as basename3,
-  dirname as dirname5,
-  extname as extname2,
-  isAbsolute as isAbsolute2,
-  join as join5,
-  resolve as resolve2
-} from "path";
+// ../../packages/schemas/src/project-apply-files/source.ts
 import { parseAllDocuments as parseYamlDocuments2 } from "yaml";
-function readProjectApplyRequest(options) {
-  if (options.file && options.directory) {
-    throw new Error("Cannot use --file with --directory.");
-  }
-  if (options.file) {
-    const request = readApplyDocumentFile(options.file);
-    const resources2 = dedupeGeneratedResources(request.resourceRecords);
-    const assets2 = readApplyAssets(
-      resources2,
-      applyFileProjectRoot(options.file)
+function readDocumentsFromSource(file2) {
+  const source = Buffer.from(file2.contentBase64, "base64").toString("utf8");
+  try {
+    const parsedDocuments = parseYamlDocuments2(source);
+    const parseError = parsedDocuments.flatMap((document) => document.errors).at(0);
+    if (parseError) {
+      throw parseError;
+    }
+    return parsedDocuments.filter((document) => document.contents !== null).map((document) => document.toJSON());
+  } catch (error51) {
+    throw new Error(
+      `Invalid apply file ${file2.path}: ${error51 instanceof Error ? error51.message : String(error51)}`
     );
-    return {
-      delete: request.delete,
-      dryRun: request.dryRun,
-      prune: request.prune,
-      resources: resources2,
-      assets: assets2
+  }
+}
+function primaryApplyDirectory() {
+  return APPLY_DIRECTORIES[RESOURCE_KIND_AGENT];
+}
+function isResourceFileUnderDirectory(path2, directory) {
+  const normalizedPath = normalizeSourcePath(path2);
+  const normalizedDirectory = normalizeSourcePath(directory);
+  return normalizedPath.startsWith(`${normalizedDirectory}/`) && /\.(json|ya?ml)$/i.test(normalizedPath);
+}
+function sourcePathJoin(...parts) {
+  return parts.map(normalizeSourcePath).filter(Boolean).join("/");
+}
+function normalizeSourcePath(path2) {
+  return path2.replaceAll("\\", "/").replace(/^\/+|\/+$/g, "");
+}
+function sourceFileIndex(files) {
+  return new Map(files.map((file2) => [normalizeSourcePath(file2.path), file2]));
+}
+function isAbsoluteSourcePath(path2) {
+  return path2.startsWith("/");
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var APPLY_DIRECTORIES, PROJECT_APPLY_RESOURCE_DIRECTORIES;
+var init_source = __esm({
+  "../../packages/schemas/src/project-apply-files/source.ts"() {
+    "use strict";
+    init_agents();
+    APPLY_DIRECTORIES = {
+      [RESOURCE_KIND_AGENT]: "agents"
     };
+    PROJECT_APPLY_RESOURCE_DIRECTORIES = Object.freeze([
+      APPLY_DIRECTORIES[RESOURCE_KIND_AGENT]
+    ]);
   }
-  const directory = options.directory ?? join5(process.cwd(), ".auto");
-  assertNoLegacySessionFiles(directory);
-  assertNoStandaloneResourceFiles(directory);
-  assertValidFragmentFiles(directory);
-  const files = applyFiles(directory);
-  if (files.length === 0) {
-    throw new Error(`No resource files found in ${directory}`);
+});
+
+// ../../packages/schemas/src/project-apply-files/agent-document-merge.ts
+import { posix } from "path";
+function readSingleDocument2(path2, fileIndex) {
+  const file2 = fileIndex.get(normalizeSourcePath(path2));
+  if (!file2) {
+    throw new Error(`Agent import not found: ${path2}`);
+  }
+  const documents = readDocumentsFromSource(file2);
+  if (documents.length !== 1) {
+    throw new Error(
+      `Agent authoring file ${file2.path} must contain exactly one document`
+    );
   }
-  const resourceRecords = [];
-  for (const { kind, path: path2 } of files) {
-    const request = readApplyDocumentFile(path2);
-    for (const { resource, generatedFromAgent } of request.resourceRecords) {
-      if (!isAllowedDirectoryResourceKind(kind, resource, generatedFromAgent)) {
-        throw new Error(
-          `Resource kind "${resource.kind}" in ${path2} does not match .auto/${primaryApplyDirectory(kind)}`
-        );
-      }
-      resourceRecords.push({ resource, generatedFromAgent });
+  return documents[0];
+}
+function importPaths2(document) {
+  const value = document.imports ?? document.import;
+  if (value === void 0) {
+    return [];
+  }
+  const values = Array.isArray(value) ? value : [value];
+  return values.map((item) => {
+    if (typeof item !== "string" || item.trim().length === 0) {
+      throw new Error("Agent imports must be non-empty string paths");
     }
+    return item.trim();
+  });
+}
+function resolveImportPath2(importPath, importerPath, fileIndex) {
+  if (isAbsoluteSourcePath(importPath) || /^[A-Za-z]+:\/\//.test(importPath)) {
+    throw new Error(`Agent import must be a relative path: ${importPath}`);
   }
-  const resources = dedupeGeneratedResources(resourceRecords);
-  const assets = readApplyAssets(resources, applyProjectRoot(directory));
+  const resolved = normalizeSourcePath(
+    posix.normalize(posix.join(posix.dirname(importerPath), importPath))
+  );
+  if (!fileIndex.has(resolved)) {
+    throw new Error(
+      `Agent import not found: ${importPath} from ${importerPath}`
+    );
+  }
+  return resolved;
+}
+function removalDirectives2(document, path2) {
+  const raw = isRecord2(document.remove) ? document.remove : {};
+  const directives = [];
+  for (const [target, value] of Object.entries(raw)) {
+    const names = stringList2(value, `remove.${target}`);
+    if (names.length > 0) {
+      directives.push({ path: path2, target, names });
+    }
+  }
+  return directives;
+}
+function stringList2(value, label) {
+  const values = Array.isArray(value) ? value : [value];
+  return values.map((item) => {
+    if (typeof item !== "string" || item.trim().length === 0) {
+      throw new Error(`${label} entries must be non-empty strings`);
+    }
+    return item.trim();
+  });
+}
+var init_agent_document_merge = __esm({
+  "../../packages/schemas/src/project-apply-files/agent-document-merge.ts"() {
+    "use strict";
+    init_source();
+  }
+});
+
+// ../../packages/schemas/src/project-apply-files/agent-fields/file-backed-string.ts
+import { posix as posix2 } from "path";
+function fileBackedStringField() {
   return {
-    delete: [],
-    dryRun: false,
-    prune: true,
-    resources,
-    assets
+    target: "spec",
+    read: (value, context) => resolveFileBackedString2(value, context)
   };
 }
-function isAllowedDirectoryResourceKind(directoryKind, resource, generatedFromAgent) {
-  if (resource.kind === directoryKind) {
-    return true;
+function resolveFileBackedString2(value, input) {
+  if (!isRecord2(value) || !("file" in value)) {
+    return value;
+  }
+  const file2 = value.file;
+  if (typeof file2 !== "string" || file2.trim().length === 0) {
+    throw new Error(
+      `Invalid agent authoring file ${input.path}: ${input.field}.file must be a non-empty string`
+    );
+  }
+  const filePath = file2.trim();
+  if (isAbsoluteSourcePath(filePath) || /^[A-Za-z]+:\/\//.test(filePath)) {
+    throw new Error(
+      `Invalid agent authoring file ${input.path}: ${input.field}.file must be a relative path`
+    );
+  }
+  const resolved = normalizeSourcePath(
+    posix2.normalize(posix2.join(posix2.dirname(input.path), filePath))
+  );
+  const source = input.fileIndex.get(resolved);
+  if (!source) {
+    throw new Error(
+      `Invalid agent authoring file ${input.path}: ${input.field}.file not found: ${filePath}`
+    );
   }
-  return directoryKind === RESOURCE_KIND_AGENT && (resource.kind === RESOURCE_KIND_ENVIRONMENT || resource.kind === RESOURCE_KIND_IDENTITY) && generatedFromAgent;
+  return Buffer.from(source.contentBase64, "base64").toString("utf8");
 }
-function dedupeGeneratedResources(records) {
-  const recordsByKey = /* @__PURE__ */ new Map();
-  const deduped = [];
-  for (const record2 of records) {
-    const { resource } = record2;
-    const key = `${resource.kind}/${resource.metadata.name}`;
-    const existing = recordsByKey.get(key);
-    if (!existing) {
-      recordsByKey.set(key, record2);
-      deduped.push(record2);
-      continue;
-    }
-    if (!record2.generatedFromAgent && !existing.generatedFromAgent) {
-      deduped.push(record2);
-      continue;
-    }
-    if (stableResource(resource) !== stableResource(existing.resource)) {
-      throw new Error(
-        `Conflicting generated resource "${key}" from agent authoring. Inline generated resources must be identical when they share a name.`
-      );
+var init_file_backed_string = __esm({
+  "../../packages/schemas/src/project-apply-files/agent-fields/file-backed-string.ts"() {
+    "use strict";
+    init_source();
+  }
+});
+
+// ../../packages/schemas/src/project-apply-files/agent-fields/helpers.ts
+function emptyAgentDraft() {
+  return { metadata: {}, spec: {} };
+}
+function cloneAgentDraft(draft) {
+  return structuredClone(draft);
+}
+function isMetadataFieldKey(key) {
+  return AGENT_METADATA_FIELD_KEYS.includes(key);
+}
+function mergeValues3(base, override) {
+  if (override === void 0) {
+    return base;
+  }
+  if (isRecord2(base) && isRecord2(override)) {
+    const merged = { ...base };
+    for (const [key, value] of Object.entries(override)) {
+      merged[key] = mergeValues3(merged[key], value);
     }
+    return merged;
   }
-  return deduped.map((record2) => record2.resource);
+  return override;
 }
 function stableResource(resource) {
   return JSON.stringify({
     kind: resource.kind,
-    metadata: metadataComparable(resource.metadata),
+    metadata: sortJson(resource.metadata),
     spec: sortJson(resource.spec)
   });
 }
-function metadataComparable(metadata) {
-  return sortJson(metadata);
-}
 function sortJson(value) {
   if (Array.isArray(value)) {
     return value.map(sortJson);
@@ -22415,65 +22456,801 @@ function sortJson(value) {
   }
   return value;
 }
-function appliedResourceKind(request, response, index) {
-  const plannedResources = response.plan.filter(
-    (item) => item.action !== "archive"
-  );
-  const kind = plannedResources[index]?.kind ?? request.resources[index]?.kind;
-  if (!kind) {
+var CONTROL_FIELDS, AGENT_METADATA_FIELD_KEYS;
+var init_helpers = __esm({
+  "../../packages/schemas/src/project-apply-files/agent-fields/helpers.ts"() {
+    "use strict";
+    init_source();
+    CONTROL_FIELDS = /* @__PURE__ */ new Set(["import", "imports", "remove"]);
+    AGENT_METADATA_FIELD_KEYS = ["name", "labels", "annotations"];
+  }
+});
+
+// ../../packages/schemas/src/project-apply-files/agent-fields/inline-resource.ts
+function inlineEnvironmentField() {
+  return {
+    target: "spec",
+    merge: (base, override) => mergeValues3(base, override),
+    compile: (value, context) => {
+      if (!isRecord2(value)) {
+        return { resources: [], value };
+      }
+      const resource = inlineEnvironmentResource2(value, context.path);
+      return { resources: [resource], value: resource.metadata.name };
+    }
+  };
+}
+function inlineIdentityField() {
+  return {
+    target: "spec",
+    merge: (base, override) => mergeValues3(base, override),
+    compile: (value, context) => {
+      if (!isRecord2(value)) {
+        return { resources: [], value };
+      }
+      const resource = inlineIdentityResource2(
+        value,
+        context.draft,
+        context.path
+      );
+      return { resources: [resource], value: resource.metadata.name };
+    }
+  };
+}
+function assertAgentAuthoringDocument(document, path2) {
+  if (!isRecord2(document) || !("kind" in document)) {
+    return;
+  }
+  if (document.kind === "session") {
     throw new Error(
-      `Apply response did not include a resource kind for item ${index}`
+      'Legacy resource kind "session" is no longer supported. Use .auto/agents with the root-level Agent facade format.'
     );
   }
-  return kind;
-}
-function mcpOAuthAgentToolConnectionsFromApplyRequest(request) {
-  return request.resources.filter((resource) => resource.kind === RESOURCE_KIND_AGENT).flatMap((resource) => {
-    return mcpOAuthAgentToolConnectionsFromAgentTools({
-      agent: resource.metadata.name,
-      tools: resource.spec.tools
-    });
+  if (document.kind === RESOURCE_KIND_ENVIRONMENT || document.kind === RESOURCE_KIND_IDENTITY) {
+    throw standaloneResourceError(document.kind, path2);
+  }
+  if (document.kind !== RESOURCE_KIND_AGENT) {
+    throw new Error(
+      `Unsupported apply resource kind "${String(document.kind)}"; supported kind is "${RESOURCE_KIND_AGENT}"`
+    );
+  }
+  const parsed = AgentApplyRequestSchema.safeParse({
+    metadata: document.metadata,
+    spec: document.spec
   });
+  if (parsed.success) {
+    throw new Error(
+      `Legacy agent resource envelopes are no longer supported in ${path2}. Use the root-level Agent facade format under .auto/agents.`
+    );
+  }
 }
-function mcpOAuthAgentToolConnectionsFromAppliedResources(resources) {
-  return resources.filter((item) => item.kind === RESOURCE_KIND_AGENT).flatMap((item) => {
-    const resource = item.resource;
-    return mcpOAuthAgentToolConnectionsFromAgentTools({
-      agent: resource.metadata.name,
-      tools: resource.spec.tools
-    });
+function parseAgentResource(draft, path2) {
+  const parsed = AgentApplyRequestSchema.safeParse({
+    metadata: draft.metadata,
+    spec: draft.spec
   });
-}
-function applyFiles(root) {
-  const agentsRoot = join5(root, primaryApplyDirectory(RESOURCE_KIND_AGENT));
-  let entries;
-  try {
-    entries = readdirSync3(agentsRoot, { withFileTypes: true });
-  } catch {
-    return [];
+  if (!parsed.success) {
+    throw new Error(`Invalid compiled agent ${path2}: ${parsed.error.message}`);
   }
-  return resourceApplyFiles(agentsRoot, entries).map((path2) => ({
+  return {
     kind: RESOURCE_KIND_AGENT,
-    path: path2
-  }));
-}
-function assertNoLegacySessionFiles(root) {
-  const path2 = join5(root, "sessions");
-  let entries;
-  try {
-    entries = readdirSync3(path2, { withFileTypes: true });
-  } catch {
-    return;
+    metadata: parsed.data.metadata,
+    spec: parsed.data.spec
+  };
+}
+function inlineEnvironmentResource2(document, path2) {
+  const parsed = EnvironmentApplyRequestSchema.safeParse(
+    splitMetadataAndSpec(document)
+  );
+  if (!parsed.success) {
+    throw new Error(
+      `Invalid inline environment in ${path2}: ${parsed.error.message}`
+    );
+  }
+  return {
+    kind: RESOURCE_KIND_ENVIRONMENT,
+    metadata: parsed.data.metadata,
+    spec: parsed.data.spec
+  };
+}
+function inlineIdentityResource2(document, agentDraft, path2) {
+  const input = splitMetadataAndSpec(document);
+  if (input.metadata.name === void 0 && typeof agentDraft.metadata.name === "string") {
+    input.metadata.name = agentDraft.metadata.name;
+  }
+  const parsed = IdentityApplyRequestSchema.safeParse(input);
+  if (!parsed.success) {
+    throw new Error(
+      `Invalid inline identity in ${path2}: ${parsed.error.message}`
+    );
+  }
+  return {
+    kind: RESOURCE_KIND_IDENTITY,
+    metadata: parsed.data.metadata,
+    spec: parsed.data.spec
+  };
+}
+function splitMetadataAndSpec(document) {
+  const metadata = {};
+  const spec = {};
+  for (const [key, value] of Object.entries(document)) {
+    if (value === void 0) {
+      continue;
+    }
+    if (isMetadataFieldKey(key)) {
+      metadata[key] = value;
+      continue;
+    }
+    spec[key] = value;
+  }
+  return { metadata, spec };
+}
+function standaloneResourceError(kind, path2) {
+  if (kind === RESOURCE_KIND_ENVIRONMENT) {
+    return new Error(
+      `Standalone environment resources are no longer supported in ${path2}. Define environments inline in .auto/agents YAML, using fragment imports under .auto/fragments/environments for reused runtimes.`
+    );
+  }
+  return new Error(
+    `Standalone identity resources are no longer supported in ${path2}. Define identities inline on the owning .auto/agents YAML file.`
+  );
+}
+var init_inline_resource = __esm({
+  "../../packages/schemas/src/project-apply-files/agent-fields/inline-resource.ts"() {
+    "use strict";
+    init_agents();
+    init_environments();
+    init_identities();
+    init_source();
+    init_helpers();
+  }
+});
+
+// ../../packages/schemas/src/project-apply-files/agent-fields/named-array.ts
+function namedArrayField(options) {
+  const remove = options.removable === false ? void 0 : removeNamedArray;
+  return {
+    target: "spec",
+    merge: (base, override) => {
+      if (!Array.isArray(base) || !Array.isArray(override)) {
+        return mergeValues3(base, override);
+      }
+      return mergeNamedArray(base, override, options.itemKey);
+    },
+    remove: remove ? (value, names) => remove(value, names, options.itemKey) : void 0
+  };
+}
+function mountsField() {
+  return namedArrayField({
+    itemKey: mountItemKey,
+    removable: false
+  });
+}
+function triggersField() {
+  return {
+    ...namedArrayField({ itemKey: triggerItemKey }),
+    compile: (value) => {
+      return {
+        resources: [],
+        value: removeAuthoringTriggerNames(value)
+      };
+    }
+  };
+}
+function mountItemKey(item) {
+  if (!isRecord2(item)) {
+    return void 0;
+  }
+  if (typeof item.name === "string") {
+    return item.name;
+  }
+  if (typeof item.mountPath === "string") {
+    return item.mountPath;
+  }
+  return void 0;
+}
+function triggerItemKey(item) {
+  if (!isRecord2(item)) {
+    return void 0;
+  }
+  if (typeof item.name === "string") {
+    return item.name;
+  }
+  if (typeof item.event === "string") {
+    return item.event;
+  }
+  if (Array.isArray(item.events)) {
+    return item.events.filter((event) => typeof event === "string").join(",");
+  }
+  if (typeof item.cron === "string") {
+    return `cron:${item.cron}:${typeof item.timezone === "string" ? item.timezone : ""}`;
+  }
+  return void 0;
+}
+function mergeNamedArray(base, override, itemKey) {
+  const merged = [...base];
+  const indexByKey = /* @__PURE__ */ new Map();
+  for (const [index, item] of merged.entries()) {
+    const key = itemKey(item);
+    if (key) {
+      indexByKey.set(key, index);
+    }
+  }
+  for (const item of override) {
+    const key = itemKey(item);
+    if (key && indexByKey.has(key)) {
+      merged[indexByKey.get(key) ?? 0] = mergeValues3(
+        merged[indexByKey.get(key) ?? 0],
+        item
+      );
+      continue;
+    }
+    if (key) {
+      indexByKey.set(key, merged.length);
+    }
+    merged.push(item);
+  }
+  return merged;
+}
+function removeNamedArray(value, names, itemKey) {
+  if (!Array.isArray(value)) {
+    return value;
+  }
+  return value.filter((item) => !names.includes(itemKey(item) ?? ""));
+}
+function removeAuthoringTriggerNames(value) {
+  if (!Array.isArray(value)) {
+    return value;
+  }
+  return value.map((trigger) => {
+    if (!isRecord2(trigger) || !("name" in trigger)) {
+      return trigger;
+    }
+    const next = { ...trigger };
+    delete next.name;
+    return next;
+  });
+}
+var init_named_array = __esm({
+  "../../packages/schemas/src/project-apply-files/agent-fields/named-array.ts"() {
+    "use strict";
+    init_source();
+    init_helpers();
+  }
+});
+
+// ../../packages/schemas/src/project-apply-files/agent-fields/named-map.ts
+function namedMapField() {
+  return {
+    target: "spec",
+    merge: (base, override) => mergeValues3(base, override),
+    remove: (value, names) => {
+      if (!isRecord2(value)) {
+        return value;
+      }
+      const next = { ...value };
+      for (const name of names) {
+        delete next[name];
+      }
+      return next;
+    }
+  };
+}
+var init_named_map = __esm({
+  "../../packages/schemas/src/project-apply-files/agent-fields/named-map.ts"() {
+    "use strict";
+    init_source();
+    init_helpers();
+  }
+});
+
+// ../../packages/schemas/src/project-apply-files/agent-fields/scalar.ts
+function metadataField() {
+  return { target: "metadata" };
+}
+function specField() {
+  return { target: "spec" };
+}
+var init_scalar = __esm({
+  "../../packages/schemas/src/project-apply-files/agent-fields/scalar.ts"() {
+    "use strict";
+  }
+});
+
+// ../../packages/schemas/src/project-apply-files/agent-fields/index.ts
+function parseAgentDraft(document, path2, fileIndex) {
+  assertAgentAuthoringDocument(document, path2);
+  const sanitized = sanitizedAgentDocument2(document);
+  assertNoLegacyEnvelopeFields(sanitized, path2);
+  const draft = emptyAgentDraft();
+  for (const [key, value] of Object.entries(sanitized)) {
+    if (value === void 0) {
+      continue;
+    }
+    const field = AGENT_FIELDS[key];
+    if (!field) {
+      continue;
+    }
+    const target = draft[field.target];
+    assertNoDuplicateFacadeField2({
+      path: path2,
+      field: key,
+      target: `${field.target}.${key}`,
+      targetValue: target[key]
+    });
+    target[key] = field.read ? field.read(value, { path: path2, field: key, fileIndex }) : value;
+  }
+  return draft;
+}
+function mergeAgentDrafts(base, override) {
+  return {
+    metadata: mergeDraftTarget("metadata", base.metadata, override.metadata),
+    spec: mergeDraftTarget("spec", base.spec, override.spec)
+  };
+}
+function applyAgentDraftRemoval(draft, removal) {
+  const field = AGENT_FIELDS[removal.target];
+  if (!field?.remove) {
+    assertSupportedAgentRemovalTarget(removal.target);
+    return draft;
+  }
+  const next = cloneAgentDraft(draft);
+  const target = next[field.target];
+  const current = target[removal.target];
+  const updated = field.remove(current, removal.names, {
+    field: removal.target
+  });
+  if (updated !== void 0 || current !== void 0) {
+    target[removal.target] = updated;
+  }
+  return next;
+}
+function assertSupportedAgentRemovalTarget(target) {
+  const supported = supportedRemovalTargets();
+  if (!supported.includes(target)) {
+    throw new Error(
+      `Unsupported agent remove target "${target}"; supported targets are ${supported.join(", ")}`
+    );
+  }
+}
+function compileAgentDraftResources(draft, path2) {
+  const next = cloneAgentDraft(draft);
+  const resources = [];
+  for (const [key, field] of Object.entries(AGENT_FIELDS)) {
+    if (field.target !== "spec") {
+      continue;
+    }
+    const value = next.spec[key];
+    if (value === void 0) {
+      continue;
+    }
+    const context = { path: path2, draft: next };
+    if (field.compile) {
+      const compiled = field.compile(value, context);
+      resources.push(...compiled.resources);
+      next.spec[key] = compiled.value;
+    }
+  }
+  const resource = parseAgentResource(next, path2);
+  return { resource, resources: [...resources, resource] };
+}
+function sanitizedAgentDocument2(document) {
+  return Object.fromEntries(
+    Object.entries(document).filter(([key]) => !CONTROL_FIELDS.has(key))
+  );
+}
+function assertNoLegacyEnvelopeFields(document, path2) {
+  const legacyEnvelopeFields = ["kind", "metadata", "spec"].filter(
+    (field) => field in document
+  );
+  if (legacyEnvelopeFields.length > 0) {
+    throw new Error(
+      `Invalid agent authoring file ${path2}: legacy resource envelope fields are no longer supported (${legacyEnvelopeFields.join(", ")}). Use root-level Agent facade fields instead.`
+    );
+  }
+}
+function mergeDraftTarget(target, base, override) {
+  const merged = { ...base };
+  for (const [key, value] of Object.entries(override)) {
+    const field = AGENT_FIELDS[key];
+    const merge2 = field?.target === target ? field.merge : void 0;
+    merged[key] = merge2 ? merge2(merged[key], value, { field: key }) : mergeValues3(merged[key], value);
+  }
+  return merged;
+}
+function assertNoDuplicateFacadeField2(input) {
+  if (input.targetValue !== void 0) {
+    throw new Error(
+      `Invalid agent authoring file ${input.path}: ${input.field} duplicates ${input.target}`
+    );
+  }
+}
+function supportedRemovalTargets() {
+  return ["tools", "triggers"].filter((key) => AGENT_FIELDS[key]?.remove);
+}
+var AGENT_FIELDS;
+var init_agent_fields = __esm({
+  "../../packages/schemas/src/project-apply-files/agent-fields/index.ts"() {
+    "use strict";
+    init_file_backed_string();
+    init_helpers();
+    init_inline_resource();
+    init_named_array();
+    init_named_map();
+    init_scalar();
+    AGENT_FIELDS = {
+      name: metadataField(),
+      labels: metadataField(),
+      annotations: metadataField(),
+      harness: specField(),
+      systemPrompt: fileBackedStringField(),
+      environment: inlineEnvironmentField(),
+      identity: inlineIdentityField(),
+      initialPrompt: fileBackedStringField(),
+      env: specField(),
+      mounts: mountsField(),
+      triggers: triggersField(),
+      workingDirectory: specField(),
+      tools: namedMapField()
+    };
+  }
+});
+
+// ../../packages/schemas/src/project-apply-files/agent-authoring.ts
+function readApplyDocument(path2, document, fileIndex) {
+  assertAgentAuthoringDocument(document, path2);
+  const result = compileAgentDocumentValue(document, path2, fileIndex);
+  return result.resources.map((resource) => ({
+    resource,
+    generatedFromAgent: resource !== result.resource
+  }));
+}
+function validateAgentFragmentDocument(document, path2, context) {
+  const normalizedPath = normalizeSourcePath(path2);
+  if (context.stack.includes(normalizedPath)) {
+    throw new Error(
+      `Agent import cycle detected: ${[...context.stack, normalizedPath].join(" -> ")}`
+    );
+  }
+  if (!isRecord2(document)) {
+    throw new Error(`Invalid agent fragment file ${path2}: expected object`);
+  }
+  for (const imported of importPaths2(document).map(
+    (importPath) => resolveImportPath2(importPath, normalizedPath, context.fileIndex)
+  )) {
+    validateAgentFragmentDocument(
+      readSingleDocument2(imported, context.fileIndex),
+      imported,
+      {
+        fileIndex: context.fileIndex,
+        stack: [...context.stack, normalizedPath]
+      }
+    );
+  }
+  for (const removal of removalDirectives2(document, normalizedPath)) {
+    assertSupportedAgentRemovalTarget(removal.target);
+  }
+  parseAgentDraft(document, normalizedPath, context.fileIndex);
+}
+function dedupeGeneratedResources(records) {
+  const recordsByKey = /* @__PURE__ */ new Map();
+  const deduped = [];
+  for (const record2 of records) {
+    const { resource } = record2;
+    const key = `${resource.kind}/${resource.metadata.name}`;
+    const existing = recordsByKey.get(key);
+    if (!existing) {
+      recordsByKey.set(key, record2);
+      deduped.push(record2);
+      continue;
+    }
+    if (!record2.generatedFromAgent && !existing.generatedFromAgent) {
+      deduped.push(record2);
+      continue;
+    }
+    if (stableResource(resource) !== stableResource(existing.resource)) {
+      throw new Error(
+        `Conflicting generated resource "${key}" from agent authoring. Inline generated resources must be identical when they share a name.`
+      );
+    }
+  }
+  return deduped.map((record2) => record2.resource);
+}
+function compileAgentDocumentValue(document, path2, fileIndex) {
+  return compileAgentDraftResources(
+    compileAgentDocument2(document, path2, {
+      fileIndex,
+      stack: []
+    }),
+    path2
+  );
+}
+function compileAgentDocument2(document, path2, context) {
+  const normalizedPath = normalizeSourcePath(path2);
+  if (context.stack.includes(normalizedPath)) {
+    throw new Error(
+      `Agent import cycle detected: ${[...context.stack, normalizedPath].join(" -> ")}`
+    );
+  }
+  if (!isRecord2(document)) {
+    throw new Error(`Invalid agent authoring file ${path2}: expected object`);
+  }
+  let merged = emptyAgentDraft();
+  for (const imported of importPaths2(document).map(
+    (importPath) => resolveImportPath2(importPath, normalizedPath, context.fileIndex)
+  )) {
+    merged = mergeAgentDrafts(
+      merged,
+      compileAgentDocument2(
+        readSingleDocument2(imported, context.fileIndex),
+        imported,
+        {
+          fileIndex: context.fileIndex,
+          stack: [...context.stack, normalizedPath]
+        }
+      )
+    );
+  }
+  for (const removal of removalDirectives2(document, normalizedPath)) {
+    merged = applyAgentDraftRemoval(merged, removal);
+  }
+  return mergeAgentDrafts(
+    merged,
+    parseAgentDraft(document, normalizedPath, context.fileIndex)
+  );
+}
+var init_agent_authoring = __esm({
+  "../../packages/schemas/src/project-apply-files/agent-authoring.ts"() {
+    "use strict";
+    init_agent_document_merge();
+    init_agent_fields();
+    init_source();
+  }
+});
+
+// ../../packages/schemas/src/project-apply-files/apply-result.ts
+function appliedResourceKind(request, response, index) {
+  const plannedResources = response.plan.filter(
+    (item) => item.action !== "archive" && isProjectApplyResourceKind(item.kind)
+  );
+  const kind = plannedResources[index]?.kind ?? request.resources[index]?.kind;
+  if (!kind) {
+    throw new Error(
+      applyResourceKindError(request, response, plannedResources, index)
+    );
+  }
+  return kind;
+}
+function mcpOAuthAgentToolConnectionsFromApplyRequest(request) {
+  return request.resources.filter((resource) => resource.kind === RESOURCE_KIND_AGENT).flatMap((resource) => {
+    return mcpOAuthAgentToolConnectionsFromAgentTools({
+      agent: resource.metadata.name,
+      tools: resource.spec.tools
+    });
+  });
+}
+function mcpOAuthAgentToolConnectionsFromAppliedResources(resources) {
+  return resources.filter((item) => item.kind === RESOURCE_KIND_AGENT).flatMap((item) => {
+    const resource = item.resource;
+    return mcpOAuthAgentToolConnectionsFromAgentTools({
+      agent: resource.metadata.name,
+      tools: resource.spec.tools
+    });
+  });
+}
+function isProjectApplyResourceKind(kind) {
+  return kind === RESOURCE_KIND_CONNECTION || kind === RESOURCE_KIND_IDENTITY || kind === RESOURCE_KIND_ENVIRONMENT || kind === RESOURCE_KIND_AGENT;
+}
+function applyResourceKindError(request, response, plannedResources, index) {
+  const planLabels = plannedResources.map(
+    (resource) => `${resource.kind}/${resource.name}`
+  );
+  const requestLabels = request.resources.map(resourceLabel);
+  return [
+    `Apply response did not include a resource kind for item ${index}.`,
+    `Unable to infer from ${planLabels.length} non-archived plan item(s) or ${requestLabels.length} request resource(s).`,
+    `Apply response contained ${response.resources.length} applied resource item(s).`,
+    `Nearby plan items: ${nearbyLabels(planLabels, index)}.`,
+    `Nearby request resources: ${nearbyLabels(requestLabels, index)}.`,
+    "This usually means the server returned an applied resource that was not represented in the apply plan or original request."
+  ].join(" ");
+}
+function nearbyLabels(labels, index) {
+  if (labels.length === 0) {
+    return "none";
+  }
+  const start = Math.max(0, Math.min(index - 2, labels.length - 3));
+  const end = Math.min(labels.length, index + 3);
+  return labels.slice(start, end).map((label, offset) => `${start + offset} ${label}`).join(", ");
+}
+function resourceLabel(resource) {
+  return `${resource.kind}/${resource.metadata.name}`;
+}
+function mcpOAuthAgentToolConnectionsFromAgentTools(input) {
+  return Object.entries(input.tools).flatMap(([alias, tool]) => {
+    if (tool.kind !== "mcp_remote" || tool.disabled || tool.auth.kind !== "mcp_oauth") {
+      return [];
+    }
+    return [
+      {
+        agent: input.agent,
+        tool: alias,
+        connection: tool.auth.connection
+      }
+    ];
+  });
+}
+var init_apply_result = __esm({
+  "../../packages/schemas/src/project-apply-files/apply-result.ts"() {
+    "use strict";
+    init_agents();
+    init_connections();
+    init_environments();
+    init_identities();
+  }
+});
+
+// ../../packages/schemas/src/project-apply-files/assets.ts
+import { createHash as createHash3 } from "crypto";
+import { extname as extname2 } from "path";
+function readApplyAssets(resources, readAsset) {
+  const assets = {};
+  for (const resource of resources) {
+    const target = avatarAssetTarget(resource);
+    if (!target || assets[target.asset]) {
+      continue;
+    }
+    if (!isAvatarAssetPathShapeValid(target.asset)) {
+      throw new Error(
+        `Invalid identity avatar asset for "${target.resourceName}": asset path must be under .auto/assets`
+      );
+    }
+    const source = readAsset(target);
+    if (!source) {
+      throw new Error(
+        `Invalid identity avatar asset for "${target.resourceName}": ${target.asset} does not exist`
+      );
+    }
+    assets[target.asset] = projectApplyAssetFromSource({
+      resourceName: target.resourceName,
+      source
+    });
+  }
+  return assets;
+}
+function projectApplyAssetFromSource(input) {
+  const bytes = Buffer.from(input.source.bytes);
+  if (bytes.length === 0 || bytes.length > MAX_AVATAR_ASSET_BYTES) {
+    throw new Error(
+      `Invalid identity avatar asset for "${input.resourceName}": asset must be ${MAX_AVATAR_ASSET_BYTES} bytes or smaller`
+    );
+  }
+  const extension = extname2(input.source.path).toLowerCase();
+  if (!ALLOWED_AVATAR_EXTENSIONS.has(extension)) {
+    throw new Error(
+      `Invalid identity avatar asset for "${input.resourceName}": asset must be a PNG or JPEG image`
+    );
+  }
+  const dimensionsProblem = avatarAssetDimensionsProblem(bytes);
+  if (dimensionsProblem) {
+    throw new Error(
+      `Invalid identity avatar asset for "${input.resourceName}": ${dimensionsProblem}`
+    );
+  }
+  return {
+    sha256: createHash3("sha256").update(bytes).digest("hex"),
+    contentType: extension === ".png" ? "image/png" : "image/jpeg",
+    dataBase64: bytes.toString("base64")
+  };
+}
+function avatarAssetTarget(resource) {
+  if (resource.kind === RESOURCE_KIND_IDENTITY) {
+    const asset = resource.spec.avatar?.asset;
+    return asset ? { asset, resourceName: resource.metadata.name } : void 0;
+  }
+  if (resource.kind === RESOURCE_KIND_AGENT && typeof resource.spec.identity === "object" && resource.spec.identity !== null && !Array.isArray(resource.spec.identity)) {
+    const asset = resource.spec.identity.avatar?.asset;
+    return asset ? { asset, resourceName: resource.metadata.name } : void 0;
+  }
+  return void 0;
+}
+var ALLOWED_AVATAR_EXTENSIONS;
+var init_assets2 = __esm({
+  "../../packages/schemas/src/project-apply-files/assets.ts"() {
+    "use strict";
+    init_agents();
+    init_identities();
+    ALLOWED_AVATAR_EXTENSIONS = /* @__PURE__ */ new Set([".jpg", ".jpeg", ".png"]);
+  }
+});
+
+// ../../packages/schemas/src/project-apply-files/index.ts
+function readProjectApplyDirectorySource(input) {
+  const resourceRoot = normalizeSourcePath(input.resourceRoot ?? "");
+  const displayResourceRoot2 = input.displayResourceRoot ?? (resourceRoot || ".auto");
+  const fileIndex = sourceFileIndex(input.files);
+  assertNoLegacySessionSourceFiles(
+    input.files,
+    resourceRoot,
+    displayResourceRoot2
+  );
+  assertNoStandaloneSourceFiles(input.files, resourceRoot, displayResourceRoot2);
+  assertValidFragmentSourceFiles(input.files, resourceRoot, fileIndex);
+  const agentFiles = input.files.filter(
+    (file2) => isResourceFileUnderDirectory(
+      file2.path,
+      sourcePathJoin(resourceRoot, primaryApplyDirectory())
+    )
+  ).sort((left, right) => left.path.localeCompare(right.path));
+  const resourceRecords = [];
+  for (const file2 of agentFiles) {
+    const request = readProjectApplyDocumentSourceFile(file2, { fileIndex });
+    resourceRecords.push(
+      ...request.resources.map((resource) => ({
+        resource,
+        generatedFromAgent: resource.kind !== RESOURCE_KIND_AGENT
+      }))
+    );
+  }
+  const resources = dedupeGeneratedResources(resourceRecords);
+  if (agentFiles.length === 0 && !input.allowEmpty) {
+    throw new Error(input.emptyMessage ?? "No resource files found");
+  }
+  return ProjectApplyRequestSchema.parse({
+    delete: [],
+    dryRun: input.dryRun ?? false,
+    prune: input.prune ?? true,
+    resources,
+    assets: readApplyAssets(resources, input.readAsset)
+  });
+}
+function readProjectApplyFileSource(input) {
+  const request = readProjectApplyDocumentSourceFile(input.file, {
+    fileIndex: sourceFileIndex(input.files ?? [input.file])
+  });
+  return ProjectApplyRequestSchema.parse({
+    ...request,
+    assets: readApplyAssets(request.resources, input.readAsset)
+  });
+}
+function readProjectApplyDocumentSourceFile(file2, options = {}) {
+  const fileIndex = options.fileIndex ?? sourceFileIndex([file2]);
+  const documents = readDocumentsFromSource(file2);
+  if (documents.length === 0) {
+    throw new Error(`Invalid apply file: ${file2.path} is empty`);
+  }
+  if (documents.length === 1) {
+    const system = ProjectApplySystemConfigSchema.safeParse(documents[0]);
+    if (system.success) {
+      return ProjectApplyRequestSchema.parse(system.data.spec);
+    }
   }
-  const files = resourceApplyFiles(path2, entries);
-  if (files.length === 0) {
+  const resourceRecords = documents.flatMap(
+    (document) => readApplyDocument(file2.path, document, fileIndex)
+  );
+  return ProjectApplyRequestSchema.parse({
+    delete: [],
+    dryRun: false,
+    prune: false,
+    resources: dedupeGeneratedResources(resourceRecords),
+    assets: {}
+  });
+}
+function assertNoLegacySessionSourceFiles(files, resourceRoot, displayResourceRoot2) {
+  const legacyFiles = files.filter(
+    (file2) => isResourceFileUnderDirectory(
+      file2.path,
+      sourcePathJoin(resourceRoot, "sessions")
+    )
+  );
+  if (legacyFiles.length === 0) {
     return;
   }
   throw new Error(
-    `Legacy .auto/sessions files are no longer supported. Move ${files.length === 1 ? "this file" : "these files"} to .auto/agents and use the root-level Agent facade format: ${files.join(", ")}`
+    `Legacy ${sourcePathJoin(displayResourceRoot2, "sessions")} files are no longer supported. Move ${legacyFiles.length === 1 ? "this file" : "these files"} to ${sourcePathJoin(displayResourceRoot2, "agents")} and use the root-level Agent facade format: ${legacyFiles.map((file2) => file2.path).join(", ")}`
   );
 }
-function assertNoStandaloneResourceFiles(root) {
+function assertNoStandaloneSourceFiles(files, resourceRoot, displayResourceRoot2) {
   for (const { directory, kind, guidance } of [
     {
       directory: "environments",
@@ -22486,151 +23263,174 @@ function assertNoStandaloneResourceFiles(root) {
       guidance: "Define identities inline on the owning .auto/agents YAML file."
     }
   ]) {
-    const path2 = join5(root, directory);
-    let entries;
-    try {
-      entries = readdirSync3(path2, { withFileTypes: true });
-    } catch {
-      continue;
-    }
-    const files = resourceApplyFiles(path2, entries);
-    if (files.length === 0) {
+    const standaloneFiles = files.filter(
+      (file2) => isResourceFileUnderDirectory(
+        file2.path,
+        sourcePathJoin(resourceRoot, directory)
+      )
+    );
+    if (standaloneFiles.length === 0) {
       continue;
     }
     throw new Error(
-      `Standalone .auto/${directory} ${kind} resources are no longer supported. ${guidance} Move ${files.length === 1 ? "this file" : "these files"}: ${files.join(", ")}`
+      `Standalone ${sourcePathJoin(displayResourceRoot2, directory)} ${kind} resources are no longer supported. ${guidance} Move ${standaloneFiles.length === 1 ? "this file" : "these files"}: ${standaloneFiles.map((file2) => file2.path).join(", ")}`
     );
   }
 }
-function assertValidFragmentFiles(root) {
-  const fragmentsRoot = join5(root, "fragments");
-  let entries;
-  try {
-    entries = readdirSync3(fragmentsRoot, { withFileTypes: true });
-  } catch {
-    return;
-  }
-  for (const path2 of resourceApplyFiles(fragmentsRoot, entries)) {
+function assertValidFragmentSourceFiles(files, resourceRoot, fileIndex) {
+  const fragments = files.filter(
+    (file2) => isResourceFileUnderDirectory(
+      file2.path,
+      sourcePathJoin(resourceRoot, "fragments")
+    )
+  );
+  for (const file2 of fragments) {
     try {
-      validateAgentFragmentFile(path2);
+      const documents = readDocumentsFromSource(file2);
+      if (documents.length !== 1) {
+        throw new Error(
+          `Agent authoring file ${file2.path} must contain exactly one document`
+        );
+      }
+      validateAgentFragmentDocument(documents[0], file2.path, {
+        fileIndex,
+        stack: []
+      });
     } catch (error51) {
       throw new Error(
-        `Invalid fragment file ${path2}: ${error51 instanceof Error ? error51.message : String(error51)}`
+        `Invalid fragment file ${file2.path}: ${error51 instanceof Error ? error51.message : String(error51)}`
       );
     }
   }
 }
-function mcpOAuthAgentToolConnectionsFromAgentTools(input) {
-  return Object.entries(input.tools).flatMap(([alias, tool]) => {
-    if (tool.kind !== "mcp_remote" || tool.disabled || tool.auth.kind !== "mcp_oauth") {
+var init_project_apply_files = __esm({
+  "../../packages/schemas/src/project-apply-files/index.ts"() {
+    "use strict";
+    init_agents();
+    init_environments();
+    init_identities();
+    init_project_resources();
+    init_agent_authoring();
+    init_apply_result();
+    init_assets2();
+    init_source();
+  }
+});
+
+// ../../packages/schemas/src/project-apply-files.ts
+var init_project_apply_files2 = __esm({
+  "../../packages/schemas/src/project-apply-files.ts"() {
+    "use strict";
+    init_project_apply_files();
+  }
+});
+
+// src/commands/apply/files.ts
+import {
+  readFileSync as readFileSync4,
+  readdirSync as readdirSync3,
+  realpathSync,
+  statSync as statSync2
+} from "fs";
+import {
+  basename as basename3,
+  dirname as dirname5,
+  extname as extname3,
+  isAbsolute as isAbsolute2,
+  join as join5,
+  relative,
+  resolve as resolve2
+} from "path";
+function readProjectApplyRequest(options) {
+  if (options.file && options.directory) {
+    throw new Error("Cannot use --file with --directory.");
+  }
+  if (options.file) {
+    const file2 = resolve2(options.file);
+    const projectRoot2 = applyFileProjectRoot(file2);
+    const sourceRoot = applyFileSourceRoot(file2, projectRoot2);
+    return readProjectApplyFileSource({
+      file: sourceFile(file2, projectRoot2),
+      files: sourceFiles(sourceRoot, projectRoot2),
+      readAsset: filesystemAssetReader(projectRoot2)
+    });
+  }
+  const directory = resolve2(options.directory ?? join5(process.cwd(), ".auto"));
+  const projectRoot = applyProjectRoot(directory);
+  return readProjectApplyDirectorySource({
+    files: sourceFiles(directory, projectRoot),
+    resourceRoot: sourcePathRelative(projectRoot, directory),
+    displayResourceRoot: displayResourceRoot(directory),
+    emptyMessage: `No resource files found in ${directory}`,
+    readAsset: filesystemAssetReader(projectRoot)
+  });
+}
+function sourceFiles(root, projectRoot) {
+  let entries;
+  try {
+    entries = readdirSync3(root, { withFileTypes: true });
+  } catch {
+    return [];
+  }
+  return entries.flatMap((entry) => {
+    const path2 = join5(root, entry.name);
+    if (entry.isDirectory()) {
+      return sourceFiles(path2, projectRoot);
+    }
+    if (!entry.isFile()) {
       return [];
     }
-    return [
-      {
-        agent: input.agent,
-        tool: alias,
-        connection: tool.auth.connection
-      }
-    ];
+    return [sourceFile(path2, projectRoot)];
   });
 }
-function readApplyDocumentFile(path2) {
-  const source = readFileSync4(path2, "utf8");
-  let documents;
-  try {
-    const parsedDocuments = parseYamlDocuments2(source);
-    const parseError = parsedDocuments.flatMap((document) => document.errors).at(0);
-    if (parseError) {
-      throw parseError;
-    }
-    documents = parsedDocuments.filter((document) => document.contents !== null).map((document) => document.toJSON());
-  } catch (error51) {
-    throw new Error(
-      `Invalid apply file: ${error51 instanceof Error ? error51.message : String(error51)}`
-    );
-  }
-  if (documents.length === 0) {
-    throw new Error(`Invalid apply file: ${path2} is empty`);
-  }
-  if (documents.length === 1) {
-    const system = ProjectApplySystemConfigSchema.safeParse(documents[0]);
-    if (system.success) {
-      const resources = system.data.spec.resources;
-      assertNoExplicitStandaloneResources(resources, path2);
-      return {
-        ...system.data.spec,
-        resourceRecords: resources.map((resource) => ({
-          resource,
-          generatedFromAgent: false
-        }))
-      };
-    }
-  }
-  const resourceRecords = documents.flatMap(
-    (document) => readApplyDocument(document, path2)
-  );
+function sourceFile(path2, projectRoot) {
   return {
-    delete: [],
-    dryRun: false,
-    prune: false,
-    resources: resourceRecords.map((record2) => record2.resource),
-    resourceRecords,
-    assets: {}
+    path: sourcePathRelative(projectRoot, path2),
+    contentBase64: readFileSync4(path2).toString("base64")
   };
 }
-function readApplyDocument(document, path2) {
-  assertAgentAuthoringDocument(document, path2);
-  const result = compileAgentDocumentValue(document, path2);
-  return result.resources.map((resource) => ({
-    resource,
-    generatedFromAgent: resource !== result.resource
-  }));
+function filesystemAssetReader(projectRoot) {
+  return ({ asset, resourceName }) => {
+    const path2 = validateAgentAvatarAsset({
+      asset,
+      resourceName,
+      projectRoot
+    });
+    return {
+      path: path2,
+      bytes: readFileSync4(path2)
+    };
+  };
 }
-function assertNoExplicitStandaloneResources(resources, path2) {
-  for (const resource of resources) {
-    if (resource.kind !== RESOURCE_KIND_ENVIRONMENT && resource.kind !== RESOURCE_KIND_IDENTITY) {
-      continue;
-    }
-    throw standaloneResourceError(resource.kind, path2);
-  }
+function applyProjectRoot(directory) {
+  const resolved = resolve2(directory);
+  return basename3(resolved) === ".auto" ? dirname5(resolved) : resolved;
 }
-function readApplyAssets(resources, projectRoot) {
-  const assets = {};
-  for (const resource of resources) {
-    const target = avatarAssetTarget(resource);
-    if (!target || assets[target.asset]) {
-      continue;
+function applyFileProjectRoot(file2) {
+  let dir = dirname5(resolve2(file2));
+  while (true) {
+    if (basename3(dir) === ".auto") {
+      return dirname5(dir);
     }
-    const resolvedPath = validateAgentAvatarAsset({
-      asset: target.asset,
-      resourceName: target.resourceName,
-      projectRoot
-    });
-    const bytes = readFileSync4(resolvedPath);
-    const dimensionsProblem = avatarAssetDimensionsProblem(bytes);
-    if (dimensionsProblem) {
-      throw new Error(
-        `Invalid identity avatar asset for "${target.resourceName}": ${dimensionsProblem}`
-      );
+    const parent = dirname5(dir);
+    if (parent === dir) {
+      return process.cwd();
     }
-    assets[target.asset] = {
-      sha256: createHash3("sha256").update(bytes).digest("hex"),
-      contentType: extname2(resolvedPath).toLowerCase() === ".png" ? "image/png" : "image/jpeg",
-      dataBase64: bytes.toString("base64")
-    };
+    dir = parent;
   }
-  return assets;
 }
-function avatarAssetTarget(resource) {
-  if (resource.kind === RESOURCE_KIND_IDENTITY) {
-    const asset = resource.spec.avatar?.asset;
-    return asset ? { asset, resourceName: resource.metadata.name } : void 0;
-  }
-  if (resource.kind === RESOURCE_KIND_AGENT && typeof resource.spec.identity === "object" && resource.spec.identity !== null && !Array.isArray(resource.spec.identity)) {
-    const asset = resource.spec.identity.avatar?.asset;
-    return asset ? { asset, resourceName: resource.metadata.name } : void 0;
-  }
-  return void 0;
+function applyFileSourceRoot(file2, projectRoot) {
+  const autoRoot = resolve2(projectRoot, ".auto");
+  return file2 === autoRoot || isInside(file2, autoRoot) ? autoRoot : dirname5(file2);
+}
+function displayResourceRoot(directory) {
+  return basename3(directory) === ".auto" ? ".auto" : directory;
+}
+function sourcePathRelative(from, to) {
+  return relative(from, to).replaceAll("\\", "/");
+}
+function isInside(path2, parent) {
+  return path2.startsWith(`${parent}/`);
 }
 function validateAgentAvatarAsset(input) {
   if (isAbsolute2(input.asset)) {
@@ -22679,103 +23479,21 @@ function validateAgentAvatarAsset(input) {
       `Invalid identity avatar asset for "${input.resourceName}": asset must be ${MAX_AVATAR_ASSET_BYTES} bytes or smaller`
     );
   }
-  const extension = extname2(resolvedAssetPath).toLowerCase();
-  if (!ALLOWED_AVATAR_EXTENSIONS.has(extension)) {
+  const extension = extname3(resolvedAssetPath).toLowerCase();
+  if (!ALLOWED_AVATAR_EXTENSIONS2.has(extension)) {
     throw new Error(
       `Invalid identity avatar asset for "${input.resourceName}": asset must be a PNG or JPEG image`
     );
   }
   return resolvedAssetPath;
 }
-function applyProjectRoot(directory) {
-  const resolved = resolve2(directory);
-  return basename3(resolved) === ".auto" ? dirname5(resolved) : resolved;
-}
-function applyFileProjectRoot(file2) {
-  let dir = dirname5(resolve2(file2));
-  while (true) {
-    if (basename3(dir) === ".auto") {
-      return dirname5(dir);
-    }
-    const parent = dirname5(dir);
-    if (parent === dir) {
-      return process.cwd();
-    }
-    dir = parent;
-  }
-}
-function isInside(path2, parent) {
-  return path2.startsWith(`${parent}/`);
-}
-function assertAgentAuthoringDocument(document, path2) {
-  if (!isRecord2(document) || !("kind" in document)) {
-    return;
-  }
-  if (document.kind === "session") {
-    throw new Error(
-      'Legacy resource kind "session" is no longer supported. Use .auto/agents with the root-level Agent facade format.'
-    );
-  }
-  if (document.kind === RESOURCE_KIND_ENVIRONMENT || document.kind === RESOURCE_KIND_IDENTITY) {
-    throw standaloneResourceError(document.kind, path2);
-  }
-  if (document.kind !== RESOURCE_KIND_AGENT) {
-    throw new Error(
-      `Unsupported apply resource kind "${String(document.kind)}"; supported kind is "${RESOURCE_KIND_AGENT}"`
-    );
-  }
-  const parsed = AgentApplyRequestSchema.safeParse({
-    metadata: document.metadata,
-    spec: document.spec
-  });
-  if (parsed.success) {
-    throw new Error(
-      `Legacy agent resource envelopes are no longer supported in ${path2}. Use the root-level Agent facade format under .auto/agents.`
-    );
-  }
-}
-function standaloneResourceError(kind, path2) {
-  if (kind === RESOURCE_KIND_ENVIRONMENT) {
-    return new Error(
-      `Standalone environment resources are no longer supported in ${path2}. Define environments inline in .auto/agents YAML, using fragment imports under .auto/fragments/environments for reused runtimes.`
-    );
-  }
-  return new Error(
-    `Standalone identity resources are no longer supported in ${path2}. Define identities inline on the owning .auto/agents YAML file.`
-  );
-}
-function primaryApplyDirectory(kind) {
-  return APPLY_DIRECTORIES[kind];
-}
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function resourceApplyFiles(directory, entries) {
-  const files = [];
-  for (const entry of entries) {
-    const path2 = join5(directory, entry.name);
-    if (entry.isDirectory()) {
-      files.push(
-        ...resourceApplyFiles(path2, readdirSync3(path2, { withFileTypes: true }))
-      );
-      continue;
-    }
-    if (entry.isFile() && /\.(json|ya?ml)$/i.test(entry.name)) {
-      files.push(path2);
-    }
-  }
-  return files.sort((left, right) => left.localeCompare(right));
-}
-var APPLY_DIRECTORIES, ALLOWED_AVATAR_EXTENSIONS;
+var ALLOWED_AVATAR_EXTENSIONS2;
 var init_files = __esm({
   "src/commands/apply/files.ts"() {
     "use strict";
     init_src();
-    init_authoring();
-    APPLY_DIRECTORIES = {
-      agent: "agents"
-    };
-    ALLOWED_AVATAR_EXTENSIONS = /* @__PURE__ */ new Set([".jpg", ".jpeg", ".png"]);
+    init_project_apply_files2();
+    ALLOWED_AVATAR_EXTENSIONS2 = /* @__PURE__ */ new Set([".jpg", ".jpeg", ".png"]);
   }
 });