@enactprotocol/cli 2.3.5 → 2.3.8

package/src/commands/org/index.ts

@@ -0,0 +1,263 @@
+/**
+ * enact org command
+ *
+ * Manage organizations for @org scoped tool namespaces.
+ *
+ * Subcommands:
+ *   - create: Create a new organization
+ *   - info: Show organization details
+ *   - list: List your organizations (TODO: requires user orgs endpoint)
+ *   - add-member: Add a member to an organization
+ *   - remove-member: Remove a member from an organization
+ *   - set-role: Change a member's role
+ */
+
+import {
+  addOrgMember,
+  createApiClient,
+  createOrg,
+  getOrg,
+  listOrgMembers,
+  removeOrgMember,
+  updateOrgMemberRole,
+} from "@enactprotocol/api";
+import { getSecret } from "@enactprotocol/secrets";
+import { loadConfig } from "@enactprotocol/shared";
+import type { OrgRole } from "@enactprotocol/shared";
+import type { Command } from "commander";
+import type { GlobalOptions } from "../../types";
+import {
+  type TableColumn,
+  dim,
+  error,
+  formatError,
+  header,
+  json,
+  keyValue,
+  newline,
+  success,
+  table,
+} from "../../utils";
+
+const AUTH_NAMESPACE = "enact:auth";
+const ACCESS_TOKEN_KEY = "access_token";
+
+const VALID_ROLES = ["owner", "admin", "member"] as const;
+
+async function getClient() {
+  const config = loadConfig();
+  const token = await getSecret(AUTH_NAMESPACE, ACCESS_TOKEN_KEY);
+  return createApiClient({
+    baseUrl: config.registry?.url,
+    authToken: token ?? undefined,
+  });
+}
+
+// ---------------------------------------------------------------------------
+// Handlers
+// ---------------------------------------------------------------------------
+
+async function createHandler(
+  name: string,
+  options: { displayName?: string; description?: string } & GlobalOptions
+) {
+  try {
+    const client = await getClient();
+    const org = await createOrg(client, {
+      name,
+      displayName: options.displayName,
+      description: options.description,
+    });
+
+    if (options.json) {
+      json(org);
+      return;
+    }
+
+    success(`Organization "@${org.name}" created`);
+    newline();
+    keyValue("Name", `@${org.name}`);
+    if (org.display_name) keyValue("Display Name", org.display_name);
+    if (org.description) keyValue("Description", org.description);
+    newline();
+    dim("You are the owner. Publish tools with:");
+    dim(`  enact publish  (with name: "@${org.name}/your-tool" in SKILL.md)`);
+  } catch (err) {
+    error(formatError(err));
+    process.exit(1);
+  }
+}
+
+async function infoHandler(name: string, options: GlobalOptions) {
+  try {
+    // Strip @ prefix if provided
+    const orgName = name.startsWith("@") ? name.substring(1) : name;
+    const client = await getClient();
+
+    const org = await getOrg(client, orgName);
+    const members = await listOrgMembers(client, orgName);
+
+    if (options.json) {
+      json({ ...org, members });
+      return;
+    }
+
+    header(`@${org.name}`);
+    if (org.display_name) keyValue("Display Name", org.display_name);
+    if (org.description) keyValue("Description", org.description);
+    keyValue("Tools", String(org.tool_count));
+    keyValue("Members", String(org.member_count));
+    keyValue("Created", org.created_at);
+
+    newline();
+    header("Members");
+    const columns: TableColumn[] = [
+      { header: "Username", key: "username", width: 20 },
+      { header: "Role", key: "role", width: 10 },
+      { header: "Added", key: "added_at", width: 20 },
+    ];
+    table(
+      members.map((m) => ({
+        username: m.username,
+        role: m.role,
+        added_at: m.added_at,
+      })),
+      columns
+    );
+  } catch (err) {
+    error(formatError(err));
+    process.exit(1);
+  }
+}
+
+async function addMemberHandler(
+  orgName: string,
+  username: string,
+  options: { role?: string } & GlobalOptions
+) {
+  try {
+    const org = orgName.startsWith("@") ? orgName.substring(1) : orgName;
+    const role = (options.role ?? "member") as OrgRole;
+
+    if (!VALID_ROLES.includes(role as (typeof VALID_ROLES)[number])) {
+      error(`Invalid role: ${role}. Must be one of: ${VALID_ROLES.join(", ")}`);
+      process.exit(1);
+    }
+
+    const client = await getClient();
+    await addOrgMember(client, org, { username, role });
+
+    if (options.json) {
+      json({ username, role, org });
+      return;
+    }
+
+    success(`Added "${username}" to @${org} as ${role}`);
+  } catch (err) {
+    error(formatError(err));
+    process.exit(1);
+  }
+}
+
+async function removeMemberHandler(orgName: string, username: string, options: GlobalOptions) {
+  try {
+    const org = orgName.startsWith("@") ? orgName.substring(1) : orgName;
+    const client = await getClient();
+    await removeOrgMember(client, org, username);
+
+    if (options.json) {
+      json({ removed: username, org });
+      return;
+    }
+
+    success(`Removed "${username}" from @${org}`);
+  } catch (err) {
+    error(formatError(err));
+    process.exit(1);
+  }
+}
+
+async function setRoleHandler(
+  orgName: string,
+  username: string,
+  role: string,
+  options: GlobalOptions
+) {
+  try {
+    const org = orgName.startsWith("@") ? orgName.substring(1) : orgName;
+
+    if (!VALID_ROLES.includes(role as (typeof VALID_ROLES)[number])) {
+      error(`Invalid role: ${role}. Must be one of: ${VALID_ROLES.join(", ")}`);
+      process.exit(1);
+    }
+
+    const client = await getClient();
+    await updateOrgMemberRole(client, org, username, role as OrgRole);
+
+    if (options.json) {
+      json({ username, role, org });
+      return;
+    }
+
+    success(`Set "${username}" role to ${role} in @${org}`);
+  } catch (err) {
+    error(formatError(err));
+    process.exit(1);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Command Configuration
+// ---------------------------------------------------------------------------
+
+export function configureOrgCommand(program: Command): void {
+  const org = program.command("org").description("Manage organizations (@org scoped namespaces)");
+
+  // enact org create <name>
+  org
+    .command("create <name>")
+    .description("Create a new organization")
+    .option("--display-name <name>", "Display name for the organization")
+    .option("--description <desc>", "Organization description")
+    .option("--json", "Output as JSON")
+    .action(async (name: string, options) => {
+      await createHandler(name, options);
+    });
+
+  // enact org info <name>
+  org
+    .command("info <name>")
+    .description("Show organization details and members")
+    .option("--json", "Output as JSON")
+    .action(async (name: string, options) => {
+      await infoHandler(name, options);
+    });
+
+  // enact org add-member <org> <username>
+  org
+    .command("add-member <org> <username>")
+    .description("Add a member to an organization")
+    .option("--role <role>", "Member role (owner, admin, member)", "member")
+    .option("--json", "Output as JSON")
+    .action(async (orgName: string, username: string, options) => {
+      await addMemberHandler(orgName, username, options);
+    });
+
+  // enact org remove-member <org> <username>
+  org
+    .command("remove-member <org> <username>")
+    .description("Remove a member from an organization")
+    .option("--json", "Output as JSON")
+    .action(async (orgName: string, username: string, options) => {
+      await removeMemberHandler(orgName, username, options);
+    });
+
+  // enact org set-role <org> <username> <role>
+  org
+    .command("set-role <org> <username> <role>")
+    .description("Change a member's role (owner, admin, member)")
+    .option("--json", "Output as JSON")
+    .action(async (orgName: string, username: string, role: string, options) => {
+      await setRoleHandler(orgName, username, role, options);
+    });
+}

package/src/commands/publish/index.ts

@@ -320,7 +320,10 @@ async function publishHandler(
     const currentUsername = await getCurrentUsername();
     if (currentUsername) {
       const toolNamespace = extractNamespace(toolName);
-      if (toolNamespace !== currentUsername) {
+      if (toolNamespace.startsWith("@")) {
+        // Org-scoped tool — server will enforce org membership
+        dim(`Publishing to organization namespace "${toolNamespace}"...`);
+      } else if (toolNamespace !== currentUsername) {
         error(
           `Namespace mismatch: Tool namespace "${toolNamespace}" does not match your username "${currentUsername}".`
         );

package/src/commands/run/README.md

@@ -10,7 +10,7 @@ enact run <tool> [options]
 
 ## Description
 
-The `run` command executes a tool using the command defined in its manifest (`skill.yaml` or `SKILL.md`). The tool runs in an isolated container environment with:
+The `run` command executes a tool using the command defined in its manifest (`skill.package.yml` or `SKILL.md`). The tool runs in an isolated container environment with:
 
 - Input validation against the tool's JSON Schema
 - Automatic secret resolution from the OS keyring

package/src/commands/search/index.ts

@@ -379,8 +379,8 @@ export function configureSearchCommand(program: Command): void {
   program
     .command("search <query>")
     .description("Search the Enact registry for tools")
-    .option("--local", "Search project tools (.enact/tools/) instead of registry")
-    .option("-g, --global", "Search global tools (~/.enact/tools/) instead of registry")
+    .option("--local", "Search project skills (agents/skills/) instead of registry")
+    .option("-g, --global", "Search global skills (~/.agents/skills/) instead of registry")
     .option("-t, --tags <tags>", "Filter by tags (comma-separated, registry only)")
     .option("-l, --limit <number>", "Maximum results to return (default: 20, registry only)")
     .option("-o, --offset <number>", "Pagination offset (default: 0, registry only)")

package/src/index.ts

@@ -22,6 +22,7 @@ import {
   configureLearnCommand,
   configureListCommand,
   configureMcpCommand,
+  configureOrgCommand,
   configurePublishCommand,
   configureReportCommand,
   configureRunCommand,
@@ -37,7 +38,7 @@ import {
 } from "./commands";
 import { error, formatError } from "./utils";
 
-export const version = "2.3.5";
+export const version = "2.3.8";
 
 // Export types for external use
 export type { GlobalOptions, CommandContext } from "./types";
@@ -93,6 +94,9 @@ async function main() {
   // Self-hosted registry
   configureServeCommand(program);
 
+  // Organizations
+  configureOrgCommand(program);
+
   // Global error handler - handle Commander's help/version exits gracefully
   program.exitOverride((err) => {
     // Commander throws errors for help, version, and other "exit" scenarios

package/src/utils/errors.ts

@@ -84,7 +84,7 @@ export class ManifestError extends CliError {
     super(
       fullMessage,
       EXIT_MANIFEST_ERROR,
-      "Ensure the directory contains a valid skill.yaml or SKILL.md file."
+      "Ensure the directory contains a valid skill.package.yaml, skill.package.yml, or SKILL.md file."
     );
     this.name = "ManifestError";
   }
@@ -377,7 +377,7 @@ export const ErrorMessages = {
     message: `No manifest found in ${dir}`,
     suggestions: [
       `Create a manifest: ${colors.command("enact init")}`,
-      "Ensure the directory contains skill.yaml or SKILL.md",
+      "Ensure the directory contains skill.package.yaml, skill.package.yml, or SKILL.md",
     ],
   }),
 

package/tests/commands/cache.test.ts

@@ -271,14 +271,14 @@ describe("cache command", () => {
       }
 
       const info: CacheInfo = {
-        path: "/Users/test/.agent/skills",
+        path: "/Users/test/.agents/skills",
         totalSize: 10_485_760, // 10 MB
         toolCount: 25,
         oldestEntry: "2024-01-01T00:00:00Z",
         newestEntry: "2024-01-20T12:00:00Z",
       };
 
-      expect(info.path).toContain(".agent");
+      expect(info.path).toContain(".agents");
       expect(info.totalSize).toBeGreaterThan(0);
       expect(info.toolCount).toBeGreaterThanOrEqual(0);
     });

package/tests/commands/init.test.ts

@@ -107,7 +107,7 @@ describe("init command", () => {
       }
     });
 
-    test("default mode creates AGENTS.md for tool consumers", async () => {
+    test("default mode creates skill.package.yaml", async () => {
       const program = new Command();
       program.exitOverride();
       configureInitCommand(program);
@@ -116,27 +116,23 @@ describe("init command", () => {
       process.chdir(testDir);
 
       try {
-        await program.parseAsync(["node", "test", "init"]);
+        await program.parseAsync(["node", "test", "init", "--name", "test/my-tool"]);
       } catch {
         // Command may throw due to exitOverride
       } finally {
         process.chdir(originalCwd);
       }
 
-      const agentsPath = join(testDir, "AGENTS.md");
-      expect(existsSync(agentsPath)).toBe(true);
+      const packagePath = join(testDir, "skill.package.yaml");
+      expect(existsSync(packagePath)).toBe(true);
 
-      const content = readFileSync(agentsPath, "utf-8");
-      expect(content).toContain("enact search");
-      expect(content).toContain("enact install");
-      expect(content).toContain("Finding & Installing Tools");
-
-      // Should NOT create enact.md in default mode
-      const manifestPath = join(testDir, "enact.md");
-      expect(existsSync(manifestPath)).toBe(false);
+      const content = readFileSync(packagePath, "utf-8");
+      expect(content).toContain("name: test/my-tool");
+      expect(content).toContain("enact:");
+      expect(content).toContain("scripts:");
     });
 
-    test("default mode creates .enact/tools.json", async () => {
+    test("default mode creates hello.py", async () => {
       const program = new Command();
       program.exitOverride();
       configureInitCommand(program);
@@ -145,18 +141,19 @@ describe("init command", () => {
       process.chdir(testDir);
 
       try {
-        await program.parseAsync(["node", "test", "init"]);
+        await program.parseAsync(["node", "test", "init", "--name", "test/my-tool"]);
       } catch {
         // Command may throw due to exitOverride
       } finally {
         process.chdir(originalCwd);
       }
 
-      const toolsJsonPath = join(testDir, ".enact", "tools.json");
-      expect(existsSync(toolsJsonPath)).toBe(true);
+      const scriptPath = join(testDir, "hello.py");
+      expect(existsSync(scriptPath)).toBe(true);
 
-      const content = JSON.parse(readFileSync(toolsJsonPath, "utf-8"));
-      expect(content).toEqual({ tools: {} });
+      const content = readFileSync(scriptPath, "utf-8");
+      expect(content).toContain("json.dumps");
+      expect(content).toContain("Hello");
     });
 
     test("--tool mode creates SKILL.md", async () => {
@@ -267,7 +264,7 @@ describe("init command", () => {
       expect(existsSync(join(testDir, "AGENTS.md"))).toBe(false);
     });
 
-    test("--agent mode creates .enact/tools.json", async () => {
+    test("--agent mode creates agents/skills.json", async () => {
       const program = new Command();
       program.exitOverride();
       configureInitCommand(program);
@@ -283,14 +280,14 @@ describe("init command", () => {
         process.chdir(originalCwd);
       }
 
-      const toolsJsonPath = join(testDir, ".enact", "tools.json");
-      expect(existsSync(toolsJsonPath)).toBe(true);
+      const skillsJsonPath = join(testDir, "agents", "skills.json");
+      expect(existsSync(skillsJsonPath)).toBe(true);
 
-      const content = JSON.parse(readFileSync(toolsJsonPath, "utf-8"));
+      const content = JSON.parse(readFileSync(skillsJsonPath, "utf-8"));
       expect(content).toEqual({ tools: {} });
     });
 
-    test("--claude mode creates .enact/tools.json", async () => {
+    test("--claude mode creates agents/skills.json", async () => {
       const program = new Command();
       program.exitOverride();
       configureInitCommand(program);
@@ -306,20 +303,20 @@ describe("init command", () => {
         process.chdir(originalCwd);
       }
 
-      const toolsJsonPath = join(testDir, ".enact", "tools.json");
-      expect(existsSync(toolsJsonPath)).toBe(true);
+      const skillsJsonPath = join(testDir, "agents", "skills.json");
+      expect(existsSync(skillsJsonPath)).toBe(true);
 
-      const content = JSON.parse(readFileSync(toolsJsonPath, "utf-8"));
+      const content = JSON.parse(readFileSync(skillsJsonPath, "utf-8"));
       expect(content).toEqual({ tools: {} });
     });
 
-    test("--agent mode with --force overwrites existing .enact/tools.json", async () => {
-      // Create existing .enact/tools.json with some content
-      const enactDir = join(testDir, ".enact");
-      mkdirSync(enactDir, { recursive: true });
-      const toolsJsonPath = join(enactDir, "tools.json");
+    test("--agent mode with --force overwrites existing agents/skills.json", async () => {
+      // Create existing agents/skills.json with some content
+      const agentsDir = join(testDir, "agents");
+      mkdirSync(agentsDir, { recursive: true });
+      const skillsJsonPath = join(agentsDir, "skills.json");
       const existingContent = { tools: { "some/tool": "1.0.0" } };
-      writeFileSync(toolsJsonPath, JSON.stringify(existingContent));
+      writeFileSync(skillsJsonPath, JSON.stringify(existingContent));
 
       const program = new Command();
       program.exitOverride();
@@ -336,17 +333,17 @@ describe("init command", () => {
         process.chdir(originalCwd);
       }
 
-      const content = JSON.parse(readFileSync(toolsJsonPath, "utf-8"));
+      const content = JSON.parse(readFileSync(skillsJsonPath, "utf-8"));
       expect(content).toEqual({ tools: {} });
     });
 
-    test("--agent mode preserves existing .enact/tools.json without --force", async () => {
-      // Create existing .enact/tools.json with some content
-      const enactDir = join(testDir, ".enact");
-      mkdirSync(enactDir, { recursive: true });
-      const toolsJsonPath = join(enactDir, "tools.json");
+    test("--agent mode preserves existing agents/skills.json without --force", async () => {
+      // Create existing agents/skills.json with some content
+      const agentsDir = join(testDir, "agents");
+      mkdirSync(agentsDir, { recursive: true });
+      const skillsJsonPath = join(agentsDir, "skills.json");
       const existingContent = { tools: { "some/tool": "1.0.0" } };
-      writeFileSync(toolsJsonPath, JSON.stringify(existingContent));
+      writeFileSync(skillsJsonPath, JSON.stringify(existingContent));
 
       // Also create AGENTS.md so the command doesn't fail early
       writeFileSync(join(testDir, "AGENTS.md"), "existing");
@@ -359,10 +356,6 @@ describe("init command", () => {
       process.chdir(testDir);
 
       try {
-        // Without --force, AGENTS.md check will fail and return early
-        // So we need to test with --force on AGENTS.md but not tools.json
-        // Actually the --force flag applies to both, so let's just verify
-        // tools.json is preserved when it exists and no --force
         await program.parseAsync(["node", "test", "init", "--agent"]);
       } catch {
         // Command may throw due to exitOverride or warning about existing file
@@ -370,12 +363,12 @@ describe("init command", () => {
         process.chdir(originalCwd);
       }
 
-      // tools.json should be preserved since AGENTS.md existed and no --force was used
-      const content = JSON.parse(readFileSync(toolsJsonPath, "utf-8"));
+      // skills.json should be preserved since AGENTS.md existed and no --force was used
+      const content = JSON.parse(readFileSync(skillsJsonPath, "utf-8"));
       expect(content).toEqual(existingContent);
     });
 
-    test("--tool mode does NOT create .enact/tools.json", async () => {
+    test("--tool mode does NOT create agents/skills.json", async () => {
       const program = new Command();
       program.exitOverride();
       configureInitCommand(program);
@@ -391,8 +384,8 @@ describe("init command", () => {
         process.chdir(originalCwd);
       }
 
-      const toolsJsonPath = join(testDir, ".enact", "tools.json");
-      expect(existsSync(toolsJsonPath)).toBe(false);
+      const skillsJsonPath = join(testDir, "agents", "skills.json");
+      expect(existsSync(skillsJsonPath)).toBe(false);
     });
 
     test("SKILL.md contains valid YAML frontmatter", async () => {
@@ -481,21 +474,39 @@ describe("init command", () => {
       expect(content).toContain("enact search");
       expect(content).toContain("enact install");
       expect(content).toContain("enact list");
-      expect(content).toContain(".enact/tools.json");
+      expect(content).toContain("agents/skills.json");
     });
   });
 
   describe("option conflicts", () => {
-    test("--agent is the default when no mode specified", () => {
+    test("default mode creates a skill when no mode specified", async () => {
       const program = new Command();
+      program.exitOverride();
       configureInitCommand(program);
 
-      const initCmd = program.commands.find((cmd) => cmd.name() === "init");
-      const opts = initCmd?.options ?? [];
-      const agentOpt = opts.find((o) => o.long === "--agent");
+      const testDir = join(import.meta.dir, ".test-init-default");
+      if (existsSync(testDir)) {
+        rmSync(testDir, { recursive: true });
+      }
+      mkdirSync(testDir, { recursive: true });
+
+      const originalCwd = process.cwd();
+      process.chdir(testDir);
+
+      try {
+        await program.parseAsync(["node", "test", "init", "--name", "test/tool"]);
+      } catch {
+        // Command may throw due to exitOverride
+      } finally {
+        process.chdir(originalCwd);
+      }
+
+      // Default should create skill files, not AGENTS.md
+      expect(existsSync(join(testDir, "skill.package.yaml"))).toBe(true);
+      expect(existsSync(join(testDir, "hello.py"))).toBe(true);
+      expect(existsSync(join(testDir, "AGENTS.md"))).toBe(false);
 
-      // Description should indicate it's the default
-      expect(agentOpt?.description).toContain("default");
+      rmSync(testDir, { recursive: true });
     });
   });
 

package/tests/commands/install-integration.test.ts

@@ -46,7 +46,7 @@ describe("install integration", () => {
     mkdirSync(join(TEST_GLOBAL_HOME, ".enact", "cache"), { recursive: true });
 
     // Create sample tool source
-    writeFileSync(join(TEST_TOOL_SRC, "skill.yaml"), SAMPLE_MANIFEST);
+    writeFileSync(join(TEST_TOOL_SRC, "skill.package.yml"), SAMPLE_MANIFEST);
   });
 
   beforeEach(() => {
@@ -92,7 +92,7 @@ describe("install integration", () => {
 
       // Verify installation
       expect(existsSync(destPath)).toBe(true);
-      expect(existsSync(join(destPath, "skill.yaml"))).toBe(true);
+      expect(existsSync(join(destPath, "skill.package.yml"))).toBe(true);
 
       // Verify manifest can be loaded from destination
       const installedManifest = loadManifestFromDir(destPath);
@@ -118,7 +118,7 @@ describe("install integration", () => {
       // Create v2 source
       const v2Source = join(TEST_BASE, "source-tool-v2");
       mkdirSync(v2Source, { recursive: true });
-      writeFileSync(join(v2Source, "skill.yaml"), SAMPLE_MANIFEST_V2);
+      writeFileSync(join(v2Source, "skill.package.yml"), SAMPLE_MANIFEST_V2);
 
       // Simulate force overwrite
       rmSync(destPath, { recursive: true, force: true });
@@ -167,9 +167,9 @@ describe("install integration", () => {
     test("global install extracts to skills path", async () => {
       const { getToolCachePath } = await import("@enactprotocol/shared");
 
-      // Verify skill path structure (~/.agent/skills/{name}/, no version subdir)
+      // Verify skill path structure (~/.agents/skills/{name}/, no version subdir)
       const skillPath = getToolCachePath("test/sample-tool", "1.0.0");
-      expect(skillPath).toContain(".agent");
+      expect(skillPath).toContain(".agents");
       expect(skillPath).toContain("skills");
       expect(skillPath).toContain("test/sample-tool");
     });
@@ -240,7 +240,7 @@ describe("install integration", () => {
       const cachePath = join(TEST_GLOBAL_HOME, ".enact", "cache", "test", "cached-tool", "v1.0.0");
       mkdirSync(cachePath, { recursive: true });
       writeFileSync(
-        join(cachePath, "skill.yaml"),
+        join(cachePath, "skill.package.yml"),
         `
 name: test/cached-tool
 version: 1.0.0
@@ -251,7 +251,7 @@ command: echo "cached"
 
       // The resolver should be able to find this tool once it's registered
       // Note: Full resolver testing is in resolver.test.ts
-      expect(existsSync(join(cachePath, "skill.yaml"))).toBe(true);
+      expect(existsSync(join(cachePath, "skill.package.yml"))).toBe(true);
     });
   });
 });
@@ -260,7 +260,7 @@ describe("tools.json edge cases", () => {
   const EDGE_TEST_DIR = join(TEST_BASE, "edge-cases");
 
   beforeAll(() => {
-    mkdirSync(join(EDGE_TEST_DIR, ".enact"), { recursive: true });
+    mkdirSync(join(EDGE_TEST_DIR, "agents"), { recursive: true });
   });
 
   afterAll(() => {
@@ -270,10 +270,10 @@ describe("tools.json edge cases", () => {
   });
 
   beforeEach(() => {
-    // Ensure .enact directory exists
-    mkdirSync(join(EDGE_TEST_DIR, ".enact"), { recursive: true });
+    // Ensure agents directory exists
+    mkdirSync(join(EDGE_TEST_DIR, "agents"), { recursive: true });
 
-    const jsonPath = join(EDGE_TEST_DIR, ".enact", "tools.json");
+    const jsonPath = join(EDGE_TEST_DIR, "agents", "skills.json");
     if (existsSync(jsonPath)) {
       rmSync(jsonPath);
     }