@autohq/cli 0.1.134 → 0.1.135

package/dist/agent-bridge.js

@@ -26273,7 +26273,7 @@ Object.assign(lookup, {
 // package.json
 var package_default = {
   name: "@autohq/cli",
-  version: "0.1.134",
+  version: "0.1.135",
   license: "SEE LICENSE IN README.md",
   publishConfig: {
     access: "public"

package/dist/index.js

@@ -334,8 +334,8 @@ async function createOAuthLoopbackCallback(input) {
   });
   let resolveResult;
   let rejectResult;
-  const result = new Promise((resolve2, reject) => {
-    resolveResult = resolve2;
+  const result = new Promise((resolve3, reject) => {
+    resolveResult = resolve3;
     rejectResult = reject;
   });
   const server = createServer((request, response) => {
@@ -595,14 +595,14 @@ async function listenOnPreferredPort(server, port) {
   }
 }
 async function listen(server, port) {
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve3, reject) => {
     const onError = (error51) => {
       server.off("listening", onListening);
       reject(error51);
     };
     const onListening = () => {
       server.off("error", onError);
-      resolve2();
+      resolve3();
     };
     server.once("error", onError);
     server.once("listening", onListening);
@@ -873,7 +873,7 @@ function persistLogin(config2, input) {
   }
 }
 async function sleep(ms) {
-  await new Promise((resolve2) => setTimeout(resolve2, ms));
+  await new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 var init_login = __esm({
   "src/commands/auth/login.ts"() {
@@ -21208,7 +21208,7 @@ var init_package = __esm({
   "package.json"() {
     package_default = {
       name: "@autohq/cli",
-      version: "0.1.134",
+      version: "0.1.135",
       license: "SEE LICENSE IN README.md",
       publishConfig: {
         access: "public"
@@ -21375,14 +21375,8 @@ var init_assets = __esm({
   }
 });
 
-// src/commands/apply/files.ts
-import { createHash as createHash3 } from "crypto";
-import {
-  readFileSync as readFileSync3,
-  readdirSync as readdirSync2,
-  realpathSync,
-  statSync
-} from "fs";
+// src/commands/agents/authoring.ts
+import { readFileSync as readFileSync3, readdirSync as readdirSync2, statSync } from "fs";
 import {
   basename as basename2,
   dirname as dirname4,
@@ -21391,7 +21385,436 @@ import {
   join as join3,
   resolve
 } from "path";
-import { parseAllDocuments as parseYamlDocuments } from "yaml";
+import { parseAllDocuments as parseYamlDocuments, stringify } from "yaml";
+function compileAgentFile(path2) {
+  const context = { graph: /* @__PURE__ */ new Map(), removals: [] };
+  const document = readSingleDocument(path2);
+  const compiled = normalizeAgentDocument(
+    compileAgentDocument(document, path2, [], context)
+  );
+  const parsed = ProjectApplyResourceSchema.safeParse(compiled);
+  if (!parsed.success) {
+    throw new Error(`Invalid compiled agent ${path2}: ${parsed.error.message}`);
+  }
+  if (parsed.data.kind !== RESOURCE_KIND_SESSION) {
+    throw new Error(
+      `Invalid compiled agent ${path2}: expected kind "agent", got "${parsed.data.kind}"`
+    );
+  }
+  return {
+    resource: parsed.data,
+    graph: [...context.graph.values()],
+    removals: context.removals
+  };
+}
+function compileAgentDocumentValue(document, path2) {
+  const context = { graph: /* @__PURE__ */ new Map(), removals: [] };
+  const compiled = normalizeAgentDocument(
+    compileAgentDocument(document, path2, [], context)
+  );
+  const parsed = ProjectApplyResourceSchema.safeParse(compiled);
+  if (!parsed.success) {
+    throw new Error(`Invalid compiled agent ${path2}: ${parsed.error.message}`);
+  }
+  if (parsed.data.kind !== RESOURCE_KIND_SESSION) {
+    throw new Error(
+      `Invalid compiled agent ${path2}: expected kind "agent", got "${parsed.data.kind}"`
+    );
+  }
+  return {
+    resource: parsed.data,
+    graph: [...context.graph.values()],
+    removals: context.removals
+  };
+}
+function renderCompiledAgentYaml(result) {
+  return stringify(result.resource).trimEnd();
+}
+function renderAgentExplain(result) {
+  const lines = [
+    `agent ${result.resource.metadata.name}`,
+    `files ${result.graph.length}`
+  ];
+  for (const node of result.graph) {
+    lines.push(node.path);
+    for (const imported of node.imports) {
+      lines.push(`  imports ${imported}`);
+    }
+  }
+  if (result.removals.length > 0) {
+    lines.push("removals");
+    for (const removal of result.removals) {
+      lines.push(
+        `  ${removal.target}: ${removal.names.join(", ")} (${removal.path})`
+      );
+    }
+  }
+  return lines.join("\n");
+}
+function readLocalAgentAuthoringStatuses(input) {
+  const agentsDirectory = join3(
+    input?.directory ?? join3(process.cwd(), ".auto"),
+    "agents"
+  );
+  let entries;
+  try {
+    entries = readdirSync2(agentsDirectory).filter(
+      (entry) => AGENT_FILE_EXTENSIONS.includes(
+        extname(
+          entry
+        ).toLowerCase()
+      )
+    ).sort((left, right) => left.localeCompare(right));
+  } catch {
+    return [];
+  }
+  return entries.map((entry) => {
+    const path2 = join3(agentsDirectory, entry);
+    const fallbackName = basename2(entry, extname(entry));
+    try {
+      const result = compileAgentFile(path2);
+      return {
+        name: result.resource.metadata.name,
+        path: path2,
+        ok: true,
+        imports: importedEdgeCount(result.graph),
+        removals: result.removals.reduce(
+          (count, removal) => count + removal.names.length,
+          0
+        )
+      };
+    } catch (error51) {
+      return {
+        name: fallbackName,
+        path: path2,
+        ok: false,
+        imports: 0,
+        removals: 0,
+        error: error51 instanceof Error ? error51.message : String(error51)
+      };
+    }
+  });
+}
+function importedAgentAuthoringPaths(paths) {
+  const imported = /* @__PURE__ */ new Set();
+  for (const path2 of paths) {
+    for (const document of readDocuments(path2)) {
+      discoverImports(document, path2, [], imported);
+    }
+  }
+  return imported;
+}
+function resolveAgentAuthoringPath(input) {
+  const candidate = resolve(input.agent);
+  if (isAgentFile(candidate)) {
+    return candidate;
+  }
+  const agentsDirectory = join3(
+    input.directory ?? join3(process.cwd(), ".auto"),
+    "agents"
+  );
+  for (const extension of AGENT_FILE_EXTENSIONS) {
+    const path2 = join3(agentsDirectory, `${input.agent}${extension}`);
+    if (isAgentFile(path2)) {
+      return path2;
+    }
+  }
+  throw new Error(
+    `Agent authoring file not found for "${input.agent}" under ${agentsDirectory}`
+  );
+}
+function discoverImports(document, path2, stack, imported) {
+  const resolvedPath = resolve(path2);
+  if (stack.includes(resolvedPath)) {
+    throw new Error(
+      `Agent import cycle detected: ${[...stack, resolvedPath].join(" -> ")}`
+    );
+  }
+  if (!isRecord2(document)) {
+    return;
+  }
+  for (const importPath of importPaths(document)) {
+    const resolvedImport = resolveImportPath(importPath, resolvedPath);
+    imported.add(resolvedImport);
+    discoverImports(
+      readSingleDocument(resolvedImport),
+      resolvedImport,
+      [...stack, resolvedPath],
+      imported
+    );
+  }
+}
+function compileAgentDocument(document, path2, stack, context) {
+  const resolvedPath = resolve(path2);
+  if (stack.includes(resolvedPath)) {
+    throw new Error(
+      `Agent import cycle detected: ${[...stack, resolvedPath].join(" -> ")}`
+    );
+  }
+  if (!isRecord2(document)) {
+    throw new Error(`Invalid agent authoring file ${path2}: expected object`);
+  }
+  const imports = importPaths(document).map(
+    (importPath) => resolveImportPath(importPath, resolvedPath)
+  );
+  context.graph.set(resolvedPath, { path: resolvedPath, imports });
+  let merged = {};
+  for (const imported of imports) {
+    const importedDocument = readSingleDocument(imported);
+    merged = mergeValues2(
+      merged,
+      compileAgentDocument(
+        importedDocument,
+        imported,
+        [...stack, resolvedPath],
+        context
+      ),
+      []
+    );
+  }
+  const removals = removalDirectives(document, resolvedPath);
+  for (const removal of removals) {
+    merged = applyRemoval(merged, removal);
+    context.removals.push(removal);
+  }
+  return mergeValues2(merged, sanitizedAgentDocument(document), []);
+}
+function readSingleDocument(path2) {
+  const documents = readDocuments(path2);
+  if (documents.length !== 1) {
+    throw new Error(
+      `Agent authoring file ${path2} must contain exactly one document`
+    );
+  }
+  return documents[0];
+}
+function readDocuments(path2) {
+  const source = readFileSync3(path2, "utf8");
+  return parseYamlDocuments(source).filter((document) => document.contents !== null).map((document) => document.toJSON());
+}
+function importPaths(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 resolveImportPath(importPath, importerPath) {
+  if (isAbsolute(importPath) || /^[A-Za-z]+:\/\//.test(importPath)) {
+    throw new Error(`Agent import must be a relative path: ${importPath}`);
+  }
+  const resolved = resolve(dirname4(importerPath), importPath);
+  if (!isAgentFile(resolved)) {
+    throw new Error(
+      `Agent import not found: ${importPath} from ${importerPath}`
+    );
+  }
+  return resolved;
+}
+function sanitizedAgentDocument(document) {
+  const next = { ...document };
+  delete next.import;
+  delete next.imports;
+  delete next.remove;
+  if (isRecord2(next.spec) && "remove" in next.spec) {
+    const spec = { ...next.spec };
+    delete spec.remove;
+    next.spec = spec;
+  }
+  return next;
+}
+function normalizeAgentDocument(document) {
+  if (!isRecord2(document) || "kind" in document) {
+    return document;
+  }
+  return { ...document, kind: RESOURCE_KIND_SESSION };
+}
+function removalDirectives(document, path2) {
+  const raw = mergeValues2(
+    isRecord2(document.remove) ? document.remove : {},
+    isRecord2(document.spec) && isRecord2(document.spec.remove) ? document.spec.remove : {},
+    []
+  );
+  if (!isRecord2(raw)) {
+    return [];
+  }
+  const directives = [];
+  for (const [target, value] of Object.entries(raw)) {
+    const names = stringList(value, `remove.${target}`);
+    if (names.length > 0) {
+      directives.push({ path: path2, target, names });
+    }
+  }
+  return directives;
+}
+function stringList(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();
+  });
+}
+function applyRemoval(value, removal) {
+  if (!isRecord2(value)) {
+    return value;
+  }
+  const next = structuredClone(value);
+  if (!isRecord2(next.spec)) {
+    return next;
+  }
+  const spec = { ...next.spec };
+  next.spec = spec;
+  switch (removal.target) {
+    case "tools":
+    case "env": {
+      if (!isRecord2(spec[removal.target])) {
+        return next;
+      }
+      const collection = {
+        ...spec[removal.target]
+      };
+      for (const name of removal.names) {
+        delete collection[name];
+      }
+      spec[removal.target] = collection;
+      return next;
+    }
+    case "mounts":
+    case "triggers": {
+      const value2 = spec[removal.target];
+      if (!Array.isArray(value2)) {
+        return next;
+      }
+      const collection = value2;
+      spec[removal.target] = collection.filter(
+        (item) => !removal.names.includes(
+          collectionItemKey(removal.target, item) ?? ""
+        )
+      );
+      return next;
+    }
+    default:
+      throw new Error(
+        `Unsupported agent remove target "${removal.target}"; supported targets are tools, env, mounts, triggers`
+      );
+  }
+}
+function mergeValues2(base, override, path2) {
+  if (override === void 0) {
+    return base;
+  }
+  if (Array.isArray(base) && Array.isArray(override)) {
+    return mergeArrays(base, override, path2);
+  }
+  if (isRecord2(base) && isRecord2(override)) {
+    const merged = { ...base };
+    for (const [key, value] of Object.entries(override)) {
+      merged[key] = mergeValues2(merged[key], value, [...path2, key]);
+    }
+    return merged;
+  }
+  return override;
+}
+function mergeArrays(base, override, path2) {
+  const pathKey = path2.join(".");
+  if (pathKey !== "spec.mounts" && pathKey !== "spec.triggers") {
+    return [...base, ...override];
+  }
+  const merged = [...base];
+  const indexByKey = /* @__PURE__ */ new Map();
+  for (const [index, item] of merged.entries()) {
+    const key = collectionItemKey(path2.at(-1) ?? "", item);
+    if (key) {
+      indexByKey.set(key, index);
+    }
+  }
+  for (const item of override) {
+    const key = collectionItemKey(path2.at(-1) ?? "", item);
+    if (key && indexByKey.has(key)) {
+      merged[indexByKey.get(key) ?? 0] = mergeValues2(
+        merged[indexByKey.get(key) ?? 0],
+        item,
+        path2
+      );
+      continue;
+    }
+    if (key) {
+      indexByKey.set(key, merged.length);
+    }
+    merged.push(item);
+  }
+  return merged;
+}
+function collectionItemKey(collection, item) {
+  if (!isRecord2(item)) {
+    return void 0;
+  }
+  if (typeof item.name === "string") {
+    return item.name;
+  }
+  if (collection === "mounts" && typeof item.mountPath === "string") {
+    return item.mountPath;
+  }
+  if (collection === "triggers") {
+    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 importedEdgeCount(graph) {
+  return graph.reduce((count, node) => count + node.imports.length, 0);
+}
+function isAgentFile(path2) {
+  try {
+    return statSync(path2).isFile();
+  } catch {
+    return false;
+  }
+}
+function isRecord2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var AGENT_FILE_EXTENSIONS;
+var init_authoring = __esm({
+  "src/commands/agents/authoring.ts"() {
+    "use strict";
+    init_src();
+    AGENT_FILE_EXTENSIONS = [".yaml", ".yml", ".json"];
+  }
+});
+
+// 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 join4,
+  resolve as resolve2
+} from "path";
+import { parseAllDocuments as parseYamlDocuments2 } from "yaml";
 function readProjectApplyRequest(options) {
   if (options.file && options.directory) {
     throw new Error("Cannot use --file with --directory.");
@@ -21404,7 +21827,7 @@ function readProjectApplyRequest(options) {
     );
     return { ...request, assets: assets2 };
   }
-  const directory = options.directory ?? join3(process.cwd(), ".auto");
+  const directory = options.directory ?? join4(process.cwd(), ".auto");
   const files = applyFiles(directory);
   if (files.length === 0) {
     throw new Error(`No resource files found in ${directory}`);
@@ -21456,24 +21879,30 @@ function mcpOAuthSessionToolConnectionsFromAppliedResources(resources) {
 function applyFiles(root) {
   const files = [];
   for (const kind of PROJECT_RESOURCE_APPLY_ORDER) {
+    const kindFiles = [];
     for (const directory of applyDirectories(kind)) {
-      const path2 = join3(root, directory);
+      const path2 = join4(root, directory);
       let entries;
       try {
-        entries = readdirSync2(path2, { withFileTypes: true });
+        entries = readdirSync3(path2, { withFileTypes: true });
       } catch {
         continue;
       }
-      files.push(
-        ...resourceApplyFiles(path2, entries).map((file2) => ({
-          kind,
-          path: file2
-        }))
-      );
+      kindFiles.push(...resourceApplyFiles(path2, entries));
     }
+    const importedFiles = kind === RESOURCE_KIND_SESSION ? importedAgentAuthoringPaths(kindFiles) : /* @__PURE__ */ new Set();
+    const appliedFiles = kind === RESOURCE_KIND_SESSION ? kindFiles.filter(
+      (path2) => !importedFiles.has(resolve2(path2)) && !isSharedAgentAuthoringFile(root, path2)
+    ) : kindFiles;
+    files.push(...appliedFiles.map((path2) => ({ kind, path: path2 })));
   }
   return files;
 }
+function isSharedAgentAuthoringFile(root, path2) {
+  const agentsSharedRoot = resolve2(root, "agents", "shared");
+  const resolvedPath = resolve2(path2);
+  return resolvedPath.startsWith(`${agentsSharedRoot}/`);
+}
 function mcpOAuthSessionToolConnectionsFromSessionTools(input) {
   return Object.entries(input.tools).flatMap(([alias, tool]) => {
     if (tool.kind !== "mcp_remote" || tool.disabled || tool.auth.kind !== "mcp_oauth") {
@@ -21489,10 +21918,10 @@ function mcpOAuthSessionToolConnectionsFromSessionTools(input) {
   });
 }
 function readApplyDocumentFile(path2) {
-  const source = readFileSync3(path2, "utf8");
+  const source = readFileSync4(path2, "utf8");
   let documents;
   try {
-    documents = parseYamlDocuments(source).filter((document) => document.contents !== null).map((document) => document.toJSON());
+    documents = parseYamlDocuments2(source).filter((document) => document.contents !== null).map((document) => document.toJSON());
   } catch (error51) {
     throw new Error(
       `Invalid apply file: ${error51 instanceof Error ? error51.message : String(error51)}`
@@ -21511,12 +21940,15 @@ function readApplyDocumentFile(path2) {
     delete: [],
     dryRun: false,
     prune: false,
-    resources: documents.map(readApplyDocument),
+    resources: documents.map((document) => readApplyDocument(document, path2)),
     assets: {}
   };
 }
-function readApplyDocument(document) {
+function readApplyDocument(document, path2) {
   const candidate = applyCandidate(document);
+  if (candidate.kind === RESOURCE_KIND_SESSION) {
+    return compileAgentDocumentValue(document, path2).resource;
+  }
   const parsed = APPLY_SCHEMAS[candidate.kind].safeParse(candidate.value);
   if (!parsed.success) {
     throw new Error(
@@ -21541,7 +21973,7 @@ function readApplyAssets(resources, projectRoot) {
       resourceName: target.resourceName,
       projectRoot
     });
-    const bytes = readFileSync3(resolvedPath);
+    const bytes = readFileSync4(resolvedPath);
     const dimensionsProblem = avatarAssetDimensionsProblem(bytes);
     if (dimensionsProblem) {
       throw new Error(
@@ -21550,7 +21982,7 @@ function readApplyAssets(resources, projectRoot) {
     }
     assets[target.asset] = {
       sha256: createHash3("sha256").update(bytes).digest("hex"),
-      contentType: extname(resolvedPath).toLowerCase() === ".png" ? "image/png" : "image/jpeg",
+      contentType: extname2(resolvedPath).toLowerCase() === ".png" ? "image/png" : "image/jpeg",
       dataBase64: bytes.toString("base64")
     };
   }
@@ -21568,7 +22000,7 @@ function avatarAssetTarget(resource) {
   return void 0;
 }
 function validateSessionAvatarAsset(input) {
-  if (isAbsolute(input.asset)) {
+  if (isAbsolute2(input.asset)) {
     throw new Error(
       `Invalid identity avatar asset for "${input.resourceName}": asset path must be relative`
     );
@@ -21580,10 +22012,10 @@ function validateSessionAvatarAsset(input) {
     );
   }
   const projectRoot = realpathSync(input.projectRoot);
-  const assetPath = resolve(projectRoot, input.asset);
+  const assetPath = resolve2(projectRoot, input.asset);
   let assetsRoot;
   try {
-    assetsRoot = realpathSync(resolve(projectRoot, ".auto", "assets"));
+    assetsRoot = realpathSync(resolve2(projectRoot, ".auto", "assets"));
   } catch {
     throw new Error(
       `Invalid identity avatar asset for "${input.resourceName}": .auto/assets directory does not exist`
@@ -21593,7 +22025,7 @@ function validateSessionAvatarAsset(input) {
   let stat;
   try {
     resolvedAssetPath = realpathSync(assetPath);
-    stat = statSync(resolvedAssetPath);
+    stat = statSync2(resolvedAssetPath);
   } catch {
     throw new Error(
       `Invalid identity avatar asset for "${input.resourceName}": ${input.asset} does not exist`
@@ -21614,7 +22046,7 @@ function validateSessionAvatarAsset(input) {
       `Invalid identity avatar asset for "${input.resourceName}": asset must be ${MAX_AVATAR_ASSET_BYTES} bytes or smaller`
     );
   }
-  const extension = extname(resolvedAssetPath).toLowerCase();
+  const extension = extname2(resolvedAssetPath).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`
@@ -21623,16 +22055,16 @@ function validateSessionAvatarAsset(input) {
   return resolvedAssetPath;
 }
 function applyProjectRoot(directory) {
-  const resolved = resolve(directory);
-  return basename2(resolved) === ".auto" ? dirname4(resolved) : resolved;
+  const resolved = resolve2(directory);
+  return basename3(resolved) === ".auto" ? dirname5(resolved) : resolved;
 }
 function applyFileProjectRoot(file2) {
-  let dir = dirname4(resolve(file2));
+  let dir = dirname5(resolve2(file2));
   while (true) {
-    if (basename2(dir) === ".auto") {
-      return dirname4(dir);
+    if (basename3(dir) === ".auto") {
+      return dirname5(dir);
     }
-    const parent = dirname4(dir);
+    const parent = dirname5(dir);
     if (parent === dir) {
       return process.cwd();
     }
@@ -21643,7 +22075,7 @@ function isInside(path2, parent) {
   return path2.startsWith(`${parent}/`);
 }
 function applyCandidate(document) {
-  if (!isRecord2(document) || !("kind" in document)) {
+  if (!isRecord3(document) || !("kind" in document)) {
     return { kind: RESOURCE_KIND_SESSION, value: document };
   }
   if (document.kind === LEGACY_RESOURCE_KIND_SESSION) {
@@ -21675,16 +22107,16 @@ function applyDirectories(kind) {
 function primaryApplyDirectory(kind) {
   return APPLY_DIRECTORIES[kind];
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function resourceApplyFiles(directory, entries) {
   const files = [];
   for (const entry of entries) {
-    const path2 = join3(directory, entry.name);
+    const path2 = join4(directory, entry.name);
     if (entry.isDirectory()) {
       files.push(
-        ...resourceApplyFiles(path2, readdirSync2(path2, { withFileTypes: true }))
+        ...resourceApplyFiles(path2, readdirSync3(path2, { withFileTypes: true }))
       );
       continue;
     }
@@ -21699,6 +22131,7 @@ var init_files = __esm({
   "src/commands/apply/files.ts"() {
     "use strict";
     init_src();
+    init_authoring();
     APPLY_DIRECTORIES = {
       environment: "environments",
       identity: "identities",
@@ -22083,10 +22516,10 @@ var init_resources3 = __esm({
 
 // src/commands/edit/actions.ts
 import { spawn as spawn2 } from "child_process";
-import { mkdtempSync, readFileSync as readFileSync4, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
+import { mkdtempSync, readFileSync as readFileSync5, rmSync as rmSync2, writeFileSync as writeFileSync3 } from "fs";
 import { tmpdir } from "os";
-import { join as join4 } from "path";
-import { parseAllDocuments as parseYamlDocuments2, stringify as stringify2 } from "yaml";
+import { join as join5 } from "path";
+import { parseAllDocuments as parseYamlDocuments3, stringify as stringify3 } from "yaml";
 async function editResource(input) {
   const reference = parseProjectResourceReference(input.resource);
   const editor = resolveEditor({
@@ -22098,15 +22531,15 @@ async function editResource(input) {
     apiBaseUrl: input.commandOptions.apiBaseUrl
   });
   const document = editableResourceDocument(reference.kind, current);
-  const source = `${stringify2(document).trimEnd()}
+  const source = `${stringify3(document).trimEnd()}
 `;
-  const tempRoot = mkdtempSync(join4(tmpdir(), "auto-edit-"));
-  const filePath = join4(tempRoot, `${reference.kind}-${reference.name}.yaml`);
+  const tempRoot = mkdtempSync(join5(tmpdir(), "auto-edit-"));
+  const filePath = join5(tempRoot, `${reference.kind}-${reference.name}.yaml`);
   writeFileSync3(filePath, source, "utf8");
   let removeTempFile = false;
   try {
     await runEditor(editor, filePath);
-    const editedSource = readFileSync4(filePath, "utf8");
+    const editedSource = readFileSync5(filePath, "utf8");
     if (editedSource === source) {
       input.writeOutput("No changes; skipped apply.");
       removeTempFile = true;
@@ -22153,7 +22586,7 @@ function resolveEditor(input) {
   return input.env.VISUAL?.trim() || input.env.EDITOR?.trim() || "vi";
 }
 async function runEditor(editor, filePath) {
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve3, reject) => {
     const child = spawn2(editor, [filePath], {
       shell: true,
       stdio: "inherit"
@@ -22165,7 +22598,7 @@ async function runEditor(editor, filePath) {
     });
     child.on("close", (code, signal) => {
       if (code === 0) {
-        resolve2();
+        resolve3();
         return;
       }
       if (signal) {
@@ -22177,10 +22610,10 @@ async function runEditor(editor, filePath) {
   });
 }
 function readEditedResource(filePath, expected) {
-  const source = readFileSync4(filePath, "utf8");
+  const source = readFileSync5(filePath, "utf8");
   let documents;
   try {
-    documents = parseYamlDocuments2(source).filter((document) => document.contents !== null).map((document) => document.toJSON());
+    documents = parseYamlDocuments3(source).filter((document) => document.contents !== null).map((document) => document.toJSON());
   } catch (error51) {
     throw new Error(
       `Invalid edited resource: ${error51 instanceof Error ? error51.message : String(error51)}`
@@ -24106,13 +24539,13 @@ function sleep2(ms, signal) {
   if (signal.aborted) {
     return Promise.resolve();
   }
-  return new Promise((resolve2) => {
-    const timeout = setTimeout(resolve2, ms);
+  return new Promise((resolve3) => {
+    const timeout = setTimeout(resolve3, ms);
     signal.addEventListener(
       "abort",
       () => {
         clearTimeout(timeout);
-        resolve2();
+        resolve3();
       },
       { once: true }
     );
@@ -25300,20 +25733,25 @@ var init_RunsView = __esm({
 // src/tui/SessionsView.tsx
 import { Box as Box11, Text as Text12, useStdout as useStdout6 } from "ink";
 import { jsx as jsx12, jsxs as jsxs10 } from "react/jsx-runtime";
-function SessionsView({ sessions, selectedIndex, error: error51 }) {
+function SessionsView({
+  sessions,
+  selectedIndex,
+  error: error51,
+  authoringStatuses
+}) {
   const { stdout } = useStdout6();
   const termWidth = stdout?.columns ?? 120;
   const numCols = 4;
   const gapTotal = (numCols - 1) * TABLE_GAP;
   const descriptionWidth = Math.max(
     24,
-    termWidth - TABLE_PADDING_X * 2 - COL_NAME2 - COL_RUNS - COL_UPDATED2 - gapTotal
+    termWidth - TABLE_PADDING_X * 2 - COL_NAME2 - COL_AUTHORING - COL_UPDATED2 - gapTotal
   );
   return /* @__PURE__ */ jsxs10(Box11, { flexDirection: "column", flexGrow: 1, children: [
     /* @__PURE__ */ jsxs10(Box11, { paddingX: TABLE_PADDING_X, paddingBottom: 1, gap: TABLE_GAP, children: [
       /* @__PURE__ */ jsx12(HeaderCell, { width: COL_NAME2, children: "NAME\u2191" }),
-      /* @__PURE__ */ jsx12(HeaderCell, { width: descriptionWidth, children: "DESCRIPTION" }),
-      /* @__PURE__ */ jsx12(HeaderCell, { width: COL_RUNS, justifyContent: "flex-end", children: "RUNS" }),
+      /* @__PURE__ */ jsx12(HeaderCell, { width: descriptionWidth, children: "CONFIG" }),
+      /* @__PURE__ */ jsx12(HeaderCell, { width: COL_AUTHORING, justifyContent: "flex-end", children: "AUTHORING" }),
       /* @__PURE__ */ jsx12(HeaderCell, { width: COL_UPDATED2, justifyContent: "flex-end", children: "UPDATED" })
     ] }),
     error51 ? /* @__PURE__ */ jsx12(Box11, { paddingX: 2, children: /* @__PURE__ */ jsxs10(Text12, { color: "red", children: [
@@ -25325,7 +25763,9 @@ function SessionsView({ sessions, selectedIndex, error: error51 }) {
     ] }) }) : sessions.map((session, i) => {
       const isSelected = i === selectedIndex;
       const updated = relativeTime3(session.metadata.updatedAt);
-      const runCount = session.status.runCount.toString();
+      const authoring = sessionAuthoringLabel(
+        authoringStatuses?.get(session.metadata.name)
+      );
       return /* @__PURE__ */ jsxs10(TableRow, { selected: isSelected, children: [
         /* @__PURE__ */ jsx12(
           TableCell,
@@ -25344,17 +25784,17 @@ function SessionsView({ sessions, selectedIndex, error: error51 }) {
             width: descriptionWidth,
             selected: isSelected,
             dim: !isSelected,
-            children: "<todo fill in>"
+            children: sessionConfigLabel(session)
           }
         ),
         /* @__PURE__ */ jsx12(
           TableCell,
           {
-            width: COL_RUNS,
+            width: COL_AUTHORING,
             selected: isSelected,
             dim: !isSelected,
             justifyContent: "flex-end",
-            children: runCount
+            children: authoring
           }
         ),
         /* @__PURE__ */ jsx12(
@@ -25371,6 +25811,26 @@ function SessionsView({ sessions, selectedIndex, error: error51 }) {
     })
   ] });
 }
+function sessionConfigLabel(session) {
+  const pieces = [
+    session.spec.harness,
+    session.spec.environment ? `env:${session.spec.environment}` : void 0,
+    `${session.status.runCount} runs`
+  ].filter(Boolean);
+  return pieces.join(" ");
+}
+function sessionAuthoringLabel(status) {
+  if (!status) {
+    return "remote";
+  }
+  if (!status.ok) {
+    return "error";
+  }
+  if (status.imports === 0 && status.removals === 0) {
+    return "local ok";
+  }
+  return `ok i${status.imports}/r${status.removals}`;
+}
 function relativeTime3(dateStr) {
   const ms = Date.now() - new Date(dateStr).getTime();
   const s = Math.floor(ms / 1e3);
@@ -25382,12 +25842,12 @@ function relativeTime3(dateStr) {
   const d = Math.floor(h / 24);
   return `${d}d ago`;
 }
-var COL_RUNS, COL_UPDATED2, COL_NAME2;
+var COL_AUTHORING, COL_UPDATED2, COL_NAME2;
 var init_SessionsView = __esm({
   "src/tui/SessionsView.tsx"() {
     "use strict";
     init_Table();
-    COL_RUNS = 6;
+    COL_AUTHORING = 16;
     COL_UPDATED2 = 10;
     COL_NAME2 = 28;
   }
@@ -25395,7 +25855,7 @@ var init_SessionsView = __esm({
 
 // src/tui/SpecInspector.tsx
 import { Box as Box12, Text as Text13 } from "ink";
-import { stringify as stringify4 } from "yaml";
+import { stringify as stringify6 } from "yaml";
 import { jsx as jsx13, jsxs as jsxs11 } from "react/jsx-runtime";
 function SpecInspector({
   kind,
@@ -25426,7 +25886,7 @@ function specLineCount(spec) {
   return yamlLines(spec).length;
 }
 function yamlLines(spec) {
-  return stringify4(spec).trimEnd().split("\n");
+  return stringify6(spec).trimEnd().split("\n");
 }
 function YamlLine({ line }) {
   const match = /^(\s*)([^:#][^:]*:)(.*)$/.exec(line);
@@ -25513,6 +25973,15 @@ function selectedNamedResourceForSection(input) {
       return null;
   }
 }
+function agentAuthoringHeaderLabel(status) {
+  if (!status.ok) {
+    return "error";
+  }
+  if (status.imports === 0 && status.removals === 0) {
+    return "local ok";
+  }
+  return `local ok, ${status.imports} imports, ${status.removals} removals`;
+}
 function editableResourceForSelection(input) {
   if (!isApplyResourceSection(input.activeSection)) {
     return null;
@@ -25571,6 +26040,15 @@ function HomeView({ apiUrl, notice, returnToSession }) {
   const [serviceAccountNameInput, setServiceAccountNameInput] = useState3("");
   const [inspectedResource, setInspectedResource] = useState3(null);
   const [inspectScrollOffset, setInspectScrollOffset] = useState3(0);
+  const localAgentAuthoringStatuses = useMemo3(
+    () => new Map(
+      readLocalAgentAuthoringStatuses().map((status) => [
+        status.name,
+        status
+      ])
+    ),
+    []
+  );
   const activeSelectionIds = client.getActiveSelection();
   const {
     data: sessions = [],
@@ -25673,6 +26151,7 @@ function HomeView({ apiUrl, notice, returnToSession }) {
   const selectedConnectionProvider = providerRows2(connectionProviders)[connectionProviderIndex];
   const selectedServiceAccount = serviceAccounts[serviceAccountIndex];
   const selectedSession = sessions[sessionIndex];
+  const selectedAgentAuthoringStatus = selectedSession ? localAgentAuthoringStatuses.get(selectedSession.metadata.name) : void 0;
   const selectedEnvironment = environments[environmentIndex];
   const selectedIdentity = identities[identityIndex];
   const selectedInspectableResource = useMemo3(() => {
@@ -26620,6 +27099,14 @@ function HomeView({ apiUrl, notice, returnToSession }) {
         activeProject && /* @__PURE__ */ jsx14(KV, { label: "Project", value: activeProject.projectName }),
         activeProject && /* @__PURE__ */ jsx14(KV, { label: "Role", value: activeProject.role }),
         selectedSession && /* @__PURE__ */ jsx14(KV, { label: "Agent", value: selectedSession.metadata.name }),
+        selectedAgentAuthoringStatus && /* @__PURE__ */ jsx14(
+          KV,
+          {
+            label: "Authoring",
+            value: agentAuthoringHeaderLabel(selectedAgentAuthoringStatus),
+            color: selectedAgentAuthoringStatus.ok ? void 0 : "red"
+          }
+        ),
         runError && /* @__PURE__ */ jsx14(KV, { label: "Error", value: runError, color: "red" }),
         isRunMutationPending && /* @__PURE__ */ jsx14(
           KV,
@@ -26768,7 +27255,8 @@ function HomeView({ apiUrl, notice, returnToSession }) {
           {
             sessions,
             selectedIndex: sessionIndex,
-            error: sessionsErrorMessage
+            error: sessionsErrorMessage,
+            authoringStatuses: localAgentAuthoringStatuses
           }
         ) : activeSection === "serviceAccounts" ? isServiceAccountsLoading ? /* @__PURE__ */ jsx14(Box13, { padding: 2, children: /* @__PURE__ */ jsx14(Spinner, { label: "loading service accounts\u2026" }) }) : /* @__PURE__ */ jsxs12(Box13, { flexDirection: "column", flexGrow: 1, children: [
           serviceAccountInputMode === "create" && /* @__PURE__ */ jsxs12(Box13, { paddingX: 2, gap: 1, children: [
@@ -27087,6 +27575,7 @@ var init_HomeView = __esm({
   "src/tui/HomeView.tsx"() {
     "use strict";
     init_src();
+    init_authoring();
     init_login();
     init_base_url();
     init_browser();
@@ -27794,8 +28283,8 @@ async function startGitCredentialRelay(input) {
     update: (next) => {
       target = { url: next.url, accessToken: next.accessToken };
     },
-    close: () => new Promise((resolve2) => {
-      server.close(() => resolve2());
+    close: () => new Promise((resolve3) => {
+      server.close(() => resolve3());
     })
   };
 }
@@ -28218,12 +28707,12 @@ async function runAgentBridgeSocket(options) {
   let handler = null;
   const reconnectLoop = createReconnectLoop(socket);
   let hasConnected = false;
-  await new Promise((resolve2, reject) => {
+  await new Promise((resolve3, reject) => {
     const shutdown = () => {
       reconnectLoop.stop();
       handler?.shutdown?.();
       socket.disconnect();
-      resolve2();
+      resolve3();
     };
     process.once("SIGINT", shutdown);
     process.once("SIGTERM", shutdown);
@@ -28406,7 +28895,7 @@ function createRuntimeBridgeBootstrapListener(input) {
   };
 }
 function emitOutputWithAck(socket, output) {
-  return new Promise((resolve2, reject) => {
+  return new Promise((resolve3, reject) => {
     socket.timeout(5e3).emit(
       RUNTIME_BRIDGE_OUTPUT_EVENT,
       output,
@@ -28426,7 +28915,7 @@ function emitOutputWithAck(socket, output) {
           );
           return;
         }
-        resolve2(ack.data);
+        resolve3(ack.data);
       }
     );
   });
@@ -29169,8 +29658,8 @@ var AsyncMessageQueue = class {
     if (this.closed) {
       return Promise.resolve({ done: true, value: void 0 });
     }
-    return new Promise((resolve2) => {
-      this.waiters.push(resolve2);
+    return new Promise((resolve3) => {
+      this.waiters.push(resolve3);
     });
   }
 };
@@ -29434,13 +29923,13 @@ var ClaudeCodeCommandHandler = class {
     this.input.writeOutput?.(
       `agent_bridge_question_pending tool_use_id=${toolUseId}`
     );
-    return new Promise((resolve2) => {
-      this.pendingQuestions.set(toolUseId, { input: toolInput, resolve: resolve2 });
+    return new Promise((resolve3) => {
+      this.pendingQuestions.set(toolUseId, { input: toolInput, resolve: resolve3 });
       options.signal.addEventListener(
         "abort",
         () => {
           if (this.pendingQuestions.delete(toolUseId)) {
-            resolve2({
+            resolve3({
               behavior: "deny",
               message: "The question was cancelled before the user answered",
               toolUseID: toolUseId
@@ -30089,7 +30578,7 @@ async function activeGrantIds(input) {
   );
 }
 async function waitForNewGrant(input, knownGrantIds) {
-  const sleep3 = input.sleep ?? ((ms) => new Promise((resolve2) => setTimeout(resolve2, ms)));
+  const sleep3 = input.sleep ?? ((ms) => new Promise((resolve3) => setTimeout(resolve3, ms)));
   const now3 = input.now ?? Date.now;
   const deadline = now3() + (input.pollTimeoutMs ?? POLL_TIMEOUT_MS);
   while (now3() < deadline) {
@@ -30786,13 +31275,13 @@ function registerDeleteCommands(program, context) {
 
 // src/commands/describe/actions.ts
 init_resources3();
-import { stringify } from "yaml";
+import { stringify as stringify2 } from "yaml";
 async function inspectResource(input) {
   const request = parseProjectResourceReference(input.resource);
   const resource = await requireProjectResource(input.client, request, {
     apiBaseUrl: input.commandOptions.apiBaseUrl
   });
-  input.writeOutput(stringify(resource.spec).trimEnd());
+  input.writeOutput(stringify2(resource.spec).trimEnd());
 }
 
 // src/commands/describe/commands.ts
@@ -31469,13 +31958,13 @@ function delay(ms, signal) {
   if (signal.aborted) {
     return Promise.resolve();
   }
-  return new Promise((resolve2) => {
-    const timeout = setTimeout(resolve2, ms);
+  return new Promise((resolve3) => {
+    const timeout = setTimeout(resolve3, ms);
     signal.addEventListener(
       "abort",
       () => {
         clearTimeout(timeout);
-        resolve2();
+        resolve3();
       },
       { once: true }
     );
@@ -31500,11 +31989,11 @@ function pollUntilFailed(input) {
   input.abort?.addEventListener("abort", cancel, { once: true });
   const done = (async () => {
     while (!cancelled) {
-      await new Promise((resolve2) => {
-        sleepResolve = resolve2;
+      await new Promise((resolve3) => {
+        sleepResolve = resolve3;
         activeSleep = setTimeout(() => {
           activeSleep = void 0;
-          resolve2();
+          resolve3();
         }, interval);
       });
       if (cancelled) {
@@ -31841,7 +32330,7 @@ function delay2(ms) {
   if (ms <= 0) {
     return Promise.resolve();
   }
-  return new Promise((resolve2) => setTimeout(resolve2, ms));
+  return new Promise((resolve3) => setTimeout(resolve3, ms));
 }
 function createDiagnosticCollector(limit) {
   const events = [];
@@ -32239,9 +32728,9 @@ function entryPreview(event, full) {
       case "text":
         return part.text;
       case "tool_call":
-        return `${part.name} ${stringify3(part.input)}`;
+        return `${part.name} ${stringify4(part.input)}`;
       case "tool_result":
-        return stringify3(part.output);
+        return stringify4(part.output);
       case "question":
         return part.questions.map((question) => question.question).join(" ");
       default:
@@ -32252,9 +32741,9 @@ function entryPreview(event, full) {
   return full ? joined : clip(joined);
 }
 function preview(value) {
-  return clip(singleLine(stringify3(value)));
+  return clip(singleLine(stringify4(value)));
 }
-function stringify3(value) {
+function stringify4(value) {
   return typeof value === "string" ? value : JSON.stringify(value);
 }
 function singleLine(text) {
@@ -32699,12 +33188,57 @@ function withApiBaseUrl2(context, commandOptions) {
   };
 }
 
+// src/commands/agents/actions.ts
+init_authoring();
+import { stringify as stringify5 } from "yaml";
+function renderAgent(input) {
+  const result = compileAgent(input);
+  input.writeOutput(renderCompiledAgentYaml(result));
+}
+function compileAgent(input) {
+  const path2 = resolveAgentAuthoringPath({
+    agent: input.agent,
+    directory: input.options.directory
+  });
+  return compileAgentFile(path2);
+}
+function compileAgentCommand(input) {
+  const result = compileAgent(input);
+  input.writeOutput(
+    input.options.json ? JSON.stringify(result.resource) : stringify5(result.resource).trimEnd()
+  );
+}
+function explainAgent(input) {
+  const result = compileAgent(input);
+  input.writeOutput(
+    input.options.json ? JSON.stringify(result) : renderAgentExplain(result)
+  );
+}
+function statusAgents(input) {
+  const statuses = readLocalAgentAuthoringStatuses({
+    directory: input.options.directory
+  });
+  if (input.options.json) {
+    input.writeOutput(JSON.stringify(statuses));
+    return;
+  }
+  if (statuses.length === 0) {
+    input.writeOutput("No local agent authoring files found.");
+    return;
+  }
+  for (const status of statuses) {
+    const state = status.ok ? "ok" : "error";
+    const suffix = status.ok ? `imports=${status.imports} removals=${status.removals}` : status.error;
+    input.writeOutput(`${state} ${status.name} ${suffix}`);
+  }
+}
+
 // src/commands/sessions/connect.ts
 init_resources2();
 init_browser();
 import { existsSync as existsSync3, mkdtempSync as mkdtempSync2, writeFileSync as writeFileSync4 } from "fs";
 import { homedir as homedir3, tmpdir as tmpdir2 } from "os";
-import { join as join5 } from "path";
+import { join as join6 } from "path";
 var POLL_INTERVAL_MS2 = 2e3;
 var POLL_TIMEOUT_MS2 = 5 * 6e4;
 var SLACK_APPS_URL = "https://api.slack.com/apps";
@@ -32756,7 +33290,7 @@ async function connectSessionPresence2(input) {
     );
     return;
   }
-  const sleep3 = input.sleep ?? ((ms) => new Promise((resolve2) => setTimeout(resolve2, ms)));
+  const sleep3 = input.sleep ?? ((ms) => new Promise((resolve3) => setTimeout(resolve3, ms)));
   const openBrowser2 = input.openBrowser ?? openBrowser;
   const now3 = input.now ?? Date.now;
   const pollIntervalMs = input.pollIntervalMs ?? POLL_INTERVAL_MS2;
@@ -32875,7 +33409,7 @@ async function promptForIconUploads(input, options) {
   }
 }
 function stagedLocationLabel(stagedPath) {
-  return stagedPath.startsWith(`${join5(homedir3(), "Downloads")}/`) ? "Downloads" : "the printed path";
+  return stagedPath.startsWith(`${join6(homedir3(), "Downloads")}/`) ? "Downloads" : "the printed path";
 }
 async function stageAvatarImage(input) {
   try {
@@ -32887,9 +33421,9 @@ async function stageAvatarImage(input) {
     }
     const contentType = response.headers.get("content-type") ?? "";
     const extension = contentType.includes("jpeg") ? ".jpg" : ".png";
-    const downloads = join5(homedir3(), "Downloads");
-    const directory = existsSync3(downloads) ? downloads : mkdtempSync2(join5(tmpdir2(), "auto-avatar-"));
-    const path2 = join5(directory, `${input.session}-avatar${extension}`);
+    const downloads = join6(homedir3(), "Downloads");
+    const directory = existsSync3(downloads) ? downloads : mkdtempSync2(join6(tmpdir2(), "auto-avatar-"));
+    const path2 = join6(directory, `${input.session}-avatar${extension}`);
     writeFileSync4(path2, Buffer.from(await response.arrayBuffer()));
     return path2;
   } catch {
@@ -32985,6 +33519,45 @@ function registerSessionCommands(program, context) {
     });
   });
   const sessions = program.command("agents").alias("sessions").description("Manage Agent resources.");
+  sessions.command("render").description("Render a local Agent authoring file after imports/removals.").argument("<agent>", "agent name or path").option(
+    "--directory <directory>",
+    "directory containing Auto resource files"
+  ).action((agent, commandOptions) => {
+    renderAgent({
+      agent,
+      options: commandOptions,
+      writeOutput: context.writeOutput
+    });
+  });
+  sessions.command("compile").description("Compile a local Agent authoring file into an apply resource.").argument("<agent>", "agent name or path").option(
+    "--directory <directory>",
+    "directory containing Auto resource files"
+  ).option("--json", "print the compiled resource as JSON").action((agent, commandOptions) => {
+    compileAgentCommand({
+      agent,
+      options: commandOptions,
+      writeOutput: context.writeOutput
+    });
+  });
+  sessions.command("explain").description("Explain a local Agent authoring file's import graph.").argument("<agent>", "agent name or path").option(
+    "--directory <directory>",
+    "directory containing Auto resource files"
+  ).option("--json", "print the import graph as JSON").action((agent, commandOptions) => {
+    explainAgent({
+      agent,
+      options: commandOptions,
+      writeOutput: context.writeOutput
+    });
+  });
+  sessions.command("status").description("Validate local Agent authoring files.").option(
+    "--directory <directory>",
+    "directory containing Auto resource files"
+  ).option("--json", "print local authoring status as JSON").action((commandOptions) => {
+    statusAgents({
+      options: commandOptions,
+      writeOutput: context.writeOutput
+    });
+  });
   sessions.command("connect").description(
     "Connect an agent's provider presence (e.g. install its Slack agent app)."
   ).argument("<session>", "agent resource name").option("--manual", "print authorization URLs without opening a browser").option(

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@autohq/cli",
-  "version": "0.1.134",
+  "version": "0.1.135",
   "license": "SEE LICENSE IN README.md",
   "publishConfig": {
     "access": "public"