ferix-code 0.0.2-beta.24 → 0.0.2-beta.26

package/dist/index.js

@@ -70,16 +70,28 @@ var init_registry = __esm({
 
 // src/index.ts
 init_esm_shims();
+import { access as access4, readdir as readdir2, readFile as readFile7 } from "fs/promises";
+import { dirname as dirname2, join as join8, resolve } from "path";
+import { cancel, isCancel, multiselect } from "@clack/prompts";
 
 // ../sync/dist/index.js
 init_esm_shims();
 
-// ../sync/dist/chunk-XQ7UIC5I.js
+// ../sync/dist/chunk-5E4WZI4D.js
 init_esm_shims();
 
-// ../sync/dist/chunk-MSWOW6ZJ.js
+// ../sync/dist/chunk-BNNEGPUU.js
 init_esm_shims();
 import { Schema as S } from "effect";
+var AgentNameSchema = S.Literal(
+  "opencode",
+  "claude-code",
+  "cursor",
+  "cline",
+  "codex",
+  "openhands",
+  "windsurf"
+);
 var PackageNameSchema = S.String.pipe(
   S.pattern(/^(@[a-z0-9-~][a-z0-9-._~]*\/)?[a-z0-9-~][a-z0-9-._~]*$/),
   S.brand("PackageName")
@@ -130,7 +142,8 @@ var SyncOptionsSchema = S.Struct({
 });
 var InstallOptionsSchema = S.Struct({
   dryRun: S.optional(S.Boolean),
-  global: S.optional(S.Boolean)
+  global: S.optional(S.Boolean),
+  agents: S.optional(S.Array(AgentNameSchema))
 });
 var SyncResultSchema = S.Struct({
   dependencies: S.Array(S.String),
@@ -149,12 +162,6 @@ var decodeSkillReposResponse = S.decodeUnknown(
 var CONVEX_URL_PROD = "https://groovy-mallard-649.convex.cloud";
 var CONVEX_URL_DEV = "https://majestic-gnu-964.convex.cloud";
 var getConvexUrl = (dev) => dev ? CONVEX_URL_DEV : CONVEX_URL_PROD;
-var NON_NPM_VERSION_PREFIXES = [
-  "workspace:",
-  "file:",
-  "link:",
-  "portal:"
-];
 
 // ../sync/dist/chunk-3LE2T6D2.js
 init_esm_shims();
@@ -6086,7 +6093,7 @@ var wrapper_default = import_websocket.default;
 var nodeWebSocket = wrapper_default;
 setDefaultWebSocketConstructor(nodeWebSocket);
 
-// ../sync/dist/chunk-XQ7UIC5I.js
+// ../sync/dist/chunk-5E4WZI4D.js
 import { Effect, Schema as S2 } from "effect";
 var findSkillRepos = (orgs, dev) => Effect.gen(function* () {
   const response = yield* Effect.tryPromise({
@@ -6116,7 +6123,7 @@ var findSkillRepos = (orgs, dev) => Effect.gen(function* () {
   return validated;
 });
 
-// ../sync/dist/chunk-FXKCLMLB.js
+// ../sync/dist/chunk-EDGIQ4IK.js
 init_esm_shims();
 import { exec } from "child_process";
 import { promisify } from "util";
@@ -6126,7 +6133,8 @@ var installSingleSkill = (repo, options) => Effect2.tryPromise({
   try: async () => {
     const repoId = `${repo.owner}/${repo.repo}`;
     const globalFlag = options.global === true ? " --global" : "";
-    const command = `npx skills add ${repoId}${globalFlag} --yes`;
+    const agentFlag = options.agents && options.agents.length > 0 ? ` --agent ${options.agents.join(" ")}` : "";
+    const command = `npx skills add ${repoId}${globalFlag}${agentFlag} --yes`;
     await execAsync(command);
     return repoId;
   },
@@ -6148,7 +6156,7 @@ var installSkills = (repos, options = {}) => {
   });
 };
 
-// ../sync/dist/chunk-BAZKO52B.js
+// ../sync/dist/chunk-C6TYE4HI.js
 init_esm_shims();
 import { Effect as Effect3, Schema as S3 } from "effect";
 var resolvePackageOrgs = (packageNames, dev) => Effect3.gen(function* () {
@@ -6180,202 +6188,60 @@ var resolvePackageOrgs = (packageNames, dev) => Effect3.gen(function* () {
 });
 
 // ../sync/dist/index.js
-import { access, readdir, readFile } from "fs/promises";
-import { dirname, join, resolve } from "path";
-import { Effect as Effect4, Schema as S4 } from "effect";
-var validateFileExists = (filePath) => Effect4.tryPromise({
+import { Effect as Effect22, Schema as S4 } from "effect";
+import { access } from "fs/promises";
+import { join } from "path";
+import { Effect as Effect4 } from "effect";
+var AGENT_DIRECTORIES = {
+  opencode: [".opencode"],
+  "claude-code": [".claude"],
+  cursor: [".cursor"],
+  cline: [".cline"],
+  codex: [".codex"],
+  openhands: [".openhands"],
+  windsurf: [".windsurf"]
+};
+var SUPPORTED_AGENTS = Object.keys(
+  AGENT_DIRECTORIES
+);
+var directoryExists = (dirPath) => Effect4.tryPromise({
   try: async () => {
-    const absolutePath = resolve(filePath);
-    await access(absolutePath);
-    return absolutePath;
+    await access(dirPath);
+    return true;
   },
-  catch: () => new PackageJsonError({
-    message: `File not found: ${filePath}`,
-    path: filePath
-  })
-});
-var readFileContent = (absolutePath) => Effect4.tryPromise({
-  try: async () => await readFile(absolutePath, "utf-8"),
-  catch: (error) => new PackageJsonError({
-    message: `Failed to read file: ${error instanceof Error ? error.message : String(error)}`,
-    path: absolutePath,
-    cause: error
-  })
-});
-var parseJson = (content, path2) => Effect4.try({
-  try: () => JSON.parse(content),
-  catch: (error) => new PackageJsonError({
-    message: `Invalid JSON: ${error instanceof Error ? error.message : String(error)}`,
-    path: path2,
-    cause: error
-  })
-});
-var validatePackageJson = (json, path2) => S4.decodeUnknown(PackageJsonSchema)(json).pipe(
-  Effect4.mapError(
-    (error) => new SchemaValidationError({
-      message: "Invalid package.json structure",
-      context: path2,
-      cause: error
-    })
+  catch: () => false
+}).pipe(Effect4.catchAll(() => Effect4.succeed(false)));
+var isAgentPresent = (projectDir, agent) => {
+  const directories = AGENT_DIRECTORIES[agent];
+  return Effect4.forEach(
+    directories,
+    (dir) => directoryExists(join(projectDir, dir))
+  ).pipe(Effect4.map((results) => results.some((exists) => exists)));
+};
+var detectAgents = (projectDir) => Effect4.forEach(
+  SUPPORTED_AGENTS,
+  (agent) => isAgentPresent(projectDir, agent).pipe(
+    Effect4.map((present) => present ? agent : null)
+  )
+).pipe(
+  Effect4.map(
+    (results) => results.filter((agent) => agent !== null)
   )
 );
-var isNonNpmDependency = (version2) => NON_NPM_VERSION_PREFIXES.some((prefix) => version2.startsWith(prefix));
-var extractDependencies = (pkg) => {
-  const deps = pkg.dependencies ?? {};
-  const devDeps = pkg.devDependencies ?? {};
-  const allDeps = /* @__PURE__ */ new Map();
-  for (const [name, version2] of Object.entries(deps)) {
-    if (!isNonNpmDependency(version2)) {
-      allDeps.set(name, version2);
-    }
-  }
-  for (const [name, version2] of Object.entries(devDeps)) {
-    if (!(allDeps.has(name) || isNonNpmDependency(version2))) {
-      allDeps.set(name, version2);
-    }
-  }
-  return Array.from(allDeps.keys());
-};
-var emptyResult = (dependencies = [], orgs = [], packageJsonCount = 1) => ({
-  dependencies: [...dependencies],
-  orgs: [...orgs],
-  skillRepos: [],
-  installed: [],
-  packageJsonCount
-});
-var toMutableSkillRepos = (repos) => repos.map((r) => ({ owner: r.owner, repo: r.repo, githubUrl: r.githubUrl }));
-var extractWorkspacePatterns = (pkg) => {
-  const workspaces = pkg.workspaces;
-  if (!workspaces) {
-    return [];
-  }
-  if (Array.isArray(workspaces)) {
-    return workspaces.filter((w) => typeof w === "string");
-  }
-  if (typeof workspaces === "object" && "packages" in workspaces) {
-    const packages = workspaces.packages;
-    if (Array.isArray(packages)) {
-      return packages.filter((w) => typeof w === "string");
-    }
-  }
-  return [];
-};
-var expandGlobPattern = async (rootDir, pattern) => {
-  if (pattern.endsWith("/*")) {
-    const baseDir = pattern.slice(0, -2);
-    const fullPath2 = join(rootDir, baseDir);
-    try {
-      const entries = await readdir(fullPath2, { withFileTypes: true });
-      return entries.filter((entry) => entry.isDirectory()).map((entry) => join(fullPath2, entry.name));
-    } catch {
-      return [];
-    }
-  }
-  if (pattern.endsWith("/**")) {
-    const baseDir = pattern.slice(0, -3);
-    const fullPath2 = join(rootDir, baseDir);
-    try {
-      const entries = await readdir(fullPath2, { withFileTypes: true });
-      return entries.filter((entry) => entry.isDirectory()).map((entry) => join(fullPath2, entry.name));
-    } catch {
-      return [];
-    }
-  }
-  const fullPath = join(rootDir, pattern);
-  try {
-    await access(fullPath);
-    return [fullPath];
-  } catch {
-    return [];
-  }
-};
-var discoverPackageJsonFiles = (rootPath, rootPkg) => Effect4.tryPromise({
-  try: async () => {
-    const rootDir = dirname(rootPath);
-    const patterns = extractWorkspacePatterns(rootPkg);
-    if (patterns.length === 0) {
-      return [rootPath];
-    }
-    const packageJsonPaths = [rootPath];
-    for (const pattern of patterns) {
-      const dirs = await expandGlobPattern(rootDir, pattern);
-      for (const dir of dirs) {
-        const pkgPath = join(dir, "package.json");
-        try {
-          await access(pkgPath);
-          packageJsonPaths.push(pkgPath);
-        } catch {
-        }
-      }
-    }
-    return packageJsonPaths;
-  },
-  catch: (error) => new PackageJsonError({
-    message: `Failed to discover workspace packages: ${error instanceof Error ? error.message : String(error)}`,
-    path: rootPath,
-    cause: error
-  })
-});
-var readPackageJson = (filePath) => Effect4.gen(function* () {
-  const content = yield* readFileContent(filePath);
-  const json = yield* parseJson(content, filePath);
-  return yield* validatePackageJson(json, filePath);
-});
-var sync = (packageJsonPath, options = {}) => Effect4.gen(function* () {
-  const absolutePath = yield* validateFileExists(packageJsonPath);
-  const rootPkg = yield* readPackageJson(absolutePath);
-  const packageJsonPaths = yield* discoverPackageJsonFiles(
-    absolutePath,
-    rootPkg
-  );
-  const packageJsonCount = packageJsonPaths.length;
-  const allDependencies = /* @__PURE__ */ new Set();
-  for (const pkgPath of packageJsonPaths) {
-    const pkg = yield* readPackageJson(pkgPath);
-    const deps = extractDependencies(pkg);
-    for (const dep of deps) {
-      allDependencies.add(dep);
-    }
-  }
-  const dependencies = Array.from(allDependencies);
-  if (dependencies.length === 0) {
-    return emptyResult([], [], packageJsonCount);
-  }
-  const packageOrgs = yield* resolvePackageOrgs(dependencies, options.dev);
-  const orgs = Array.from(
-    new Set(
-      packageOrgs.map((p) => p.githubOrg).filter((org) => org !== null)
-    )
-  );
-  if (orgs.length === 0) {
-    return emptyResult([...dependencies], [], packageJsonCount);
-  }
-  const skillRepos = yield* findSkillRepos(orgs, options.dev);
-  if (skillRepos.length === 0) {
-    return emptyResult([...dependencies], orgs, packageJsonCount);
-  }
-  const installed = yield* installSkills(skillRepos, {
-    dryRun: options.dryRun,
-    global: options.global
-  });
-  return {
-    dependencies: [...dependencies],
-    orgs,
-    skillRepos: toMutableSkillRepos(skillRepos),
-    installed: [...installed],
-    packageJsonCount
-  };
-});
+var validateAgentNames = (agents) => agents.filter(
+  (agent) => !SUPPORTED_AGENTS.includes(agent)
+);
 
 // src/index.ts
 import { Command } from "commander";
-import { Effect as Effect29 } from "effect";
+import { Effect as Effect30 } from "effect";
+import ora from "ora";
 import pc17 from "picocolors";
 
 // package.json
 var package_default = {
   name: "ferix-code",
-  version: "0.0.2-beta.24",
+  version: "0.0.2-beta.26",
   description: "Composable RALPH loops for AI coding agents - v2 with Effect",
   type: "module",
   bin: {
@@ -6394,9 +6260,11 @@ var package_default = {
     bump: "npm version prerelease --preid=beta --workspaces=false && bun run build && bun publish --tag beta"
   },
   dependencies: {
+    "@clack/prompts": "catalog:",
     commander: "^14.0.0",
     effect: "^3.19.15",
     "human-id": "^4.1.3",
+    ora: "^9.1.0",
     picocolors: "^1.1.1"
   },
   devDependencies: {
@@ -6423,7 +6291,7 @@ var package_default = {
 
 // src/program.ts
 init_esm_shims();
-import { Effect as Effect28, Stream as Stream10 } from "effect";
+import { Effect as Effect29, Stream as Stream10 } from "effect";
 
 // src/consumers/index.ts
 init_esm_shims();
@@ -8881,10 +8749,10 @@ import {
   appendFile,
   copyFile,
   mkdir,
-  readFile as readFile2,
+  readFile,
   rm
 } from "fs/promises";
-import { dirname as dirname2, join as join2 } from "path";
+import { dirname, join as join2 } from "path";
 import { promisify as promisify2 } from "util";
 import { Effect as Effect8, Layer } from "effect";
 
@@ -8951,7 +8819,7 @@ function gitExec(command, cwd) {
     }
   });
 }
-function directoryExists(dirPath) {
+function directoryExists2(dirPath) {
   return Effect8.tryPromise({
     try: async () => {
       await access2(dirPath);
@@ -8998,7 +8866,7 @@ function copyUntrackedFiles(worktreeDir) {
       const destPath = join2(worktreeDir, file);
       yield* Effect8.tryPromise({
         try: async () => {
-          await mkdir(dirname2(destPath), { recursive: true });
+          await mkdir(dirname(destPath), { recursive: true });
           await copyFile(srcPath, destPath);
         },
         catch: () => new GitError({
@@ -9010,7 +8878,7 @@ function copyUntrackedFiles(worktreeDir) {
     yield* Effect8.tryPromise({
       try: async () => {
         const gitFilePath = join2(worktreeDir, ".git");
-        const gitFileContent = await readFile2(gitFilePath, "utf-8");
+        const gitFileContent = await readFile(gitFilePath, "utf-8");
         const gitDirMatch = gitFileContent.match(GITDIR_REGEX);
         const gitDirPath = gitDirMatch?.[1]?.trim();
         if (!gitDirPath) {
@@ -9018,7 +8886,7 @@ function copyUntrackedFiles(worktreeDir) {
         }
         const gitDir = gitDirPath;
         const excludePath = join2(gitDir, "info", "exclude");
-        await mkdir(dirname2(excludePath), { recursive: true });
+        await mkdir(dirname(excludePath), { recursive: true });
         const excludeContent = "\n# Untracked files copied from main worktree (auto-generated by ferix)\n" + untrackedFiles.join("\n") + "\n";
         await appendFile(excludePath, excludeContent);
       },
@@ -9042,7 +8910,7 @@ var make = {
         cause: error
       })
     });
-    const exists = yield* directoryExists(worktreeDir);
+    const exists = yield* directoryExists2(worktreeDir);
     if (exists) {
       return worktreeDir;
     }
@@ -9063,7 +8931,7 @@ var make = {
   removeWorktree: (sessionId) => Effect8.gen(function* () {
     const worktreeDir = getWorktreeDir(sessionId);
     const branchName = getBranchName(sessionId);
-    const exists = yield* directoryExists(worktreeDir);
+    const exists = yield* directoryExists2(worktreeDir);
     if (!exists) {
       return;
     }
@@ -9096,7 +8964,7 @@ var make = {
   }),
   removeWorktreeKeepBranch: (sessionId) => Effect8.gen(function* () {
     const worktreeDir = getWorktreeDir(sessionId);
-    const exists = yield* directoryExists(worktreeDir);
+    const exists = yield* directoryExists2(worktreeDir);
     if (!exists) {
       return;
     }
@@ -9126,12 +8994,12 @@ var make = {
   }),
   getWorktreePath: (sessionId) => Effect8.gen(function* () {
     const worktreeDir = getWorktreeDir(sessionId);
-    const exists = yield* directoryExists(worktreeDir);
+    const exists = yield* directoryExists2(worktreeDir);
     return exists ? worktreeDir : void 0;
   }),
   commitChanges: (sessionId, message) => Effect8.gen(function* () {
     const worktreeDir = getWorktreeDir(sessionId);
-    const exists = yield* directoryExists(worktreeDir);
+    const exists = yield* directoryExists2(worktreeDir);
     if (!exists) {
       return yield* Effect8.fail(
         new GitError({
@@ -9187,7 +9055,7 @@ var make = {
   }),
   pushBranch: (sessionId) => Effect8.gen(function* () {
     const worktreeDir = getWorktreeDir(sessionId);
-    const exists = yield* directoryExists(worktreeDir);
+    const exists = yield* directoryExists2(worktreeDir);
     if (!exists) {
       return yield* Effect8.fail(
         new GitError({
@@ -9208,7 +9076,7 @@ var make = {
   }),
   createPR: (sessionId, title, body, baseBranch) => Effect8.gen(function* () {
     const worktreeDir = getWorktreeDir(sessionId);
-    const exists = yield* directoryExists(worktreeDir);
+    const exists = yield* directoryExists2(worktreeDir);
     if (!exists) {
       return yield* Effect8.fail(
         new GitError({
@@ -9246,7 +9114,7 @@ var make = {
   renameBranch: (sessionId, displayName) => Effect8.gen(function* () {
     const worktreeDir = getWorktreeDir(sessionId);
     const oldBranchName = getBranchName(sessionId);
-    const exists = yield* directoryExists(worktreeDir);
+    const exists = yield* directoryExists2(worktreeDir);
     if (!exists) {
       return yield* Effect8.fail(
         new GitError({
@@ -9409,7 +9277,7 @@ var MemoryGit = {
 
 // src/layers/guardrails/file-system.ts
 init_esm_shims();
-import { mkdir as mkdir2, readFile as readFile3, writeFile } from "fs/promises";
+import { mkdir as mkdir2, readFile as readFile2, writeFile } from "fs/promises";
 import { join as join3 } from "path";
 import { DateTime, Effect as Effect10, Layer as Layer3 } from "effect";
 
@@ -10477,7 +10345,7 @@ var make2 = {
     const existing = yield* Effect10.tryPromise({
       try: async () => {
         try {
-          const content = await readFile3(guardrailsPath, "utf-8");
+          const content = await readFile2(guardrailsPath, "utf-8");
           return content;
         } catch {
           return null;
@@ -10526,7 +10394,7 @@ var make2 = {
     const content = yield* Effect10.tryPromise({
       try: async () => {
         try {
-          return await readFile3(guardrailsPath, "utf-8");
+          return await readFile2(guardrailsPath, "utf-8");
         } catch {
           return null;
         }
@@ -11081,7 +10949,7 @@ function createProviderLayer2(name) {
 
 // src/layers/plan/file-system.ts
 init_esm_shims();
-import { access as access3, mkdir as mkdir3, readdir as readdir2, readFile as readFile4, writeFile as writeFile2 } from "fs/promises";
+import { access as access3, mkdir as mkdir3, readdir, readFile as readFile3, writeFile as writeFile2 } from "fs/promises";
 import { join as join4 } from "path";
 import { Effect as Effect16, Layer as Layer7 } from "effect";
 
@@ -11147,7 +11015,7 @@ var make3 = {
     const existingPlans = yield* Effect16.tryPromise({
       try: async () => {
         try {
-          const files = await readdir2(sessionDir);
+          const files = await readdir(sessionDir);
           return files.filter((f) => f.endsWith(".json")).length;
         } catch {
           return 0;
@@ -11175,7 +11043,7 @@ var make3 = {
     if (sessionId) {
       const planPath = getPlanPath(sessionId, planId);
       const content = yield* Effect16.tryPromise({
-        try: () => readFile4(planPath, "utf-8"),
+        try: () => readFile3(planPath, "utf-8"),
         catch: (error) => new PlanStoreError({
           message: `Failed to read plan file: ${planPath}`,
           operation: "load",
@@ -11187,7 +11055,7 @@ var make3 = {
     const sessionDirs = yield* Effect16.tryPromise({
       try: async () => {
         const plansDir = join4(process.cwd(), PLANS_DIR2);
-        const dirs = await readdir2(plansDir);
+        const dirs = await readdir(plansDir);
         return dirs;
       },
       catch: (error) => new PlanStoreError({
@@ -11210,7 +11078,7 @@ var make3 = {
       }).pipe(Effect16.orElseSucceed(() => false));
       if (exists) {
         const content = yield* Effect16.tryPromise({
-          try: () => readFile4(planPath, "utf-8"),
+          try: () => readFile3(planPath, "utf-8"),
           catch: (error) => new PlanStoreError({
             message: `Failed to read plan file: ${planPath}`,
             operation: "load",
@@ -11243,7 +11111,7 @@ var make3 = {
     const files = yield* Effect16.tryPromise({
       try: async () => {
         try {
-          return await readdir2(sessionDir);
+          return await readdir(sessionDir);
         } catch {
           return [];
         }
@@ -11351,7 +11219,7 @@ var MemoryPlan = {
 
 // src/layers/progress/file-system.ts
 init_esm_shims();
-import { mkdir as mkdir4, readFile as readFile5, writeFile as writeFile3 } from "fs/promises";
+import { mkdir as mkdir4, readFile as readFile4, writeFile as writeFile3 } from "fs/promises";
 import { join as join5 } from "path";
 import { DateTime as DateTime3, Effect as Effect18, Layer as Layer9 } from "effect";
 
@@ -11419,7 +11287,7 @@ var make4 = {
     const existing = yield* Effect18.tryPromise({
       try: async () => {
         try {
-          const content = await readFile5(progressPath, "utf-8");
+          const content = await readFile4(progressPath, "utf-8");
           return content;
         } catch {
           return null;
@@ -11464,7 +11332,7 @@ var make4 = {
     const content = yield* Effect18.tryPromise({
       try: async () => {
         try {
-          return await readFile5(progressPath, "utf-8");
+          return await readFile4(progressPath, "utf-8");
         } catch {
           return null;
         }
@@ -11555,7 +11423,7 @@ var MemoryProgress = {
 
 // src/layers/session/file-system.ts
 init_esm_shims();
-import { mkdir as mkdir5, readFile as readFile6, writeFile as writeFile4 } from "fs/promises";
+import { mkdir as mkdir5, readFile as readFile5, writeFile as writeFile4 } from "fs/promises";
 import { join as join6 } from "path";
 import { DateTime as DateTime5, Effect as Effect20, Layer as Layer11 } from "effect";
 import { humanId } from "human-id";
@@ -11638,7 +11506,7 @@ var make5 = {
   get: (sessionId) => Effect20.gen(function* () {
     const sessionPath = getSessionPath(sessionId);
     const content = yield* Effect20.tryPromise({
-      try: () => readFile6(sessionPath, "utf-8"),
+      try: () => readFile5(sessionPath, "utf-8"),
       catch: (error) => new SessionStoreError({
         message: `Failed to read session file: ${sessionPath}`,
         operation: "get",
@@ -11731,7 +11599,7 @@ var MemorySession = {
 
 // src/layers/signal/ferix-parser.ts
 init_esm_shims();
-import { Effect as Effect22, Layer as Layer13, Ref as Ref8 } from "effect";
+import { Effect as Effect23, Layer as Layer13, Ref as Ref8 } from "effect";
 
 // src/services/signal-parser.ts
 init_esm_shims();
@@ -12246,10 +12114,10 @@ signalSpecRegistry.register(tasksDefinedSpec);
 // src/layers/signal/ferix-parser.ts
 var MAX_BUFFER_SIZE = 1024 * 1024;
 function createAccumulatorImpl() {
-  return Effect22.gen(function* () {
+  return Effect23.gen(function* () {
     const chunksRef = yield* Ref8.make([]);
     const emittedRef = yield* Ref8.make(/* @__PURE__ */ new Set());
-    const feed = (text) => Effect22.gen(function* () {
+    const feed = (text) => Effect23.gen(function* () {
       const chunks = yield* Ref8.get(chunksRef);
       chunks.push(text);
       const buffer = chunks.join("");
@@ -12277,7 +12145,7 @@ function createAccumulatorImpl() {
       yield* Ref8.set(emittedRef, emitted);
       return newSignals;
     });
-    const flush = () => Effect22.gen(function* () {
+    const flush = () => Effect23.gen(function* () {
       const chunks = yield* Ref8.get(chunksRef);
       const buffer = chunks.join("");
       yield* Ref8.set(chunksRef, []);
@@ -12293,7 +12161,7 @@ function createAccumulatorImpl() {
   });
 }
 var make6 = {
-  parse: (text) => Effect22.succeed(signalSpecRegistry.parseAll(text)),
+  parse: (text) => Effect23.succeed(signalSpecRegistry.parseAll(text)),
   createAccumulator: createAccumulatorImpl
 };
 var Live15 = Layer13.succeed(SignalParser, make6);
@@ -12349,27 +12217,27 @@ init_esm_shims();
 
 // src/orchestrator/loop.ts
 init_esm_shims();
-import { DateTime as DateTime10, Effect as Effect27, Option, pipe as pipe3, Ref as Ref12, Stream as Stream9 } from "effect";
+import { DateTime as DateTime10, Effect as Effect28, Option, pipe as pipe3, Ref as Ref12, Stream as Stream9 } from "effect";
 
 // src/orchestrator/discovery.ts
 init_esm_shims();
-import { DateTime as DateTime8, Effect as Effect25, pipe, Ref as Ref10, Stream as Stream7 } from "effect";
+import { DateTime as DateTime8, Effect as Effect26, pipe, Ref as Ref10, Stream as Stream7 } from "effect";
 
 // src/layers/plan/task-generation.ts
 init_esm_shims();
-import { mkdir as mkdir6, readFile as readFile7, writeFile as writeFile5 } from "fs/promises";
+import { mkdir as mkdir6, readFile as readFile6, writeFile as writeFile5 } from "fs/promises";
 import { join as join7 } from "path";
-import { Effect as Effect23 } from "effect";
+import { Effect as Effect24 } from "effect";
 var PLANS_DIR4 = ".ferix/plans";
 function ensureDir5(dirPath) {
-  return Effect23.tryPromise({
+  return Effect24.tryPromise({
     try: () => mkdir6(dirPath, { recursive: true }),
     catch: (error) => new PlanStoreError({
       message: `Failed to create directory: ${dirPath}`,
       operation: "create",
       cause: error
     })
-  }).pipe(Effect23.asVoid);
+  }).pipe(Effect24.asVoid);
 }
 function getSessionDir4(sessionId) {
   return join7(process.cwd(), PLANS_DIR4, sessionId);
@@ -12378,12 +12246,12 @@ function getTasksMdPath(sessionId) {
   return join7(getSessionDir4(sessionId), "tasks.md");
 }
 function writeTasksMd(sessionId, tasks) {
-  return Effect23.gen(function* () {
+  return Effect24.gen(function* () {
     const sessionDir = getSessionDir4(sessionId);
     yield* ensureDir5(sessionDir);
     const tasksMdPath = getTasksMdPath(sessionId);
     const content = formatTasksMd(tasks);
-    yield* Effect23.tryPromise({
+    yield* Effect24.tryPromise({
       try: () => writeFile5(tasksMdPath, content, "utf-8"),
       catch: (error) => new PlanStoreError({
         message: `Failed to write tasks.md: ${tasksMdPath}`,
@@ -12575,7 +12443,7 @@ function mapSignalToDomain(signal, context) {
 
 // src/orchestrator/plan-updates.ts
 init_esm_shims();
-import { DateTime as DateTime7, Effect as Effect24, Ref as Ref9 } from "effect";
+import { DateTime as DateTime7, Effect as Effect25, Ref as Ref9 } from "effect";
 
 // src/orchestrator/plan-updates/index.ts
 init_esm_shims();
@@ -12897,9 +12765,9 @@ function persistPlanUpdate(planStore, plan, operation) {
     tasks: plan.tasks
   }) : planStore.update(plan.id, plan);
   return storeOp.pipe(
-    Effect24.map(() => null),
-    Effect24.catchAll(
-      (error) => Effect24.succeed({
+    Effect25.map(() => null),
+    Effect25.catchAll(
+      (error) => Effect25.succeed({
         _tag: "PlanUpdateFailed",
         operation,
         error: error.message,
@@ -12909,7 +12777,7 @@ function persistPlanUpdate(planStore, plan, operation) {
   );
 }
 function updatePlanFromSignal(currentPlanRef, persistenceStateRef, signal, sessionId, originalTask) {
-  return Effect24.gen(function* () {
+  return Effect25.gen(function* () {
     const currentPlan = yield* Ref9.get(currentPlanRef);
     const now = yield* DateTime7.now;
     const timestamp = DateTime7.formatIso(now);
@@ -12931,7 +12799,7 @@ function updatePlanFromSignal(currentPlanRef, persistenceStateRef, signal, sessi
   });
 }
 function flushPlanPersistence(planStore, currentPlanRef, persistenceStateRef) {
-  return Effect24.gen(function* () {
+  return Effect25.gen(function* () {
     const state = yield* Ref9.get(persistenceStateRef);
     if (!(state.dirty && state.pendingOperation)) {
       return [];
@@ -13255,12 +13123,12 @@ function areAllTasksComplete(plan) {
 
 // src/orchestrator/discovery.ts
 function processTextSignals(signalParser, text, context) {
-  return Effect25.gen(function* () {
+  return Effect26.gen(function* () {
     const events = [];
     const parsedSignals = [];
     const signals = yield* signalParser.parse(text).pipe(
-      Effect25.tapError(
-        (error) => Effect25.logDebug(
+      Effect26.tapError(
+        (error) => Effect26.logDebug(
           "Signal parsing failed, continuing with empty signals",
           {
             error: String(error),
@@ -13268,7 +13136,7 @@ function processTextSignals(signalParser, text, context) {
           }
         )
       ),
-      Effect25.orElseSucceed(() => [])
+      Effect26.orElseSucceed(() => [])
     );
     for (const signal of signals) {
       events.push(mapSignalToDomain(signal, context));
@@ -13278,7 +13146,7 @@ function processTextSignals(signalParser, text, context) {
   });
 }
 function processLLMEvent(signalParser, llmEvent, context) {
-  return Effect25.gen(function* () {
+  return Effect26.gen(function* () {
     const domainEvent = mapLLMEventToDomain(llmEvent, context);
     const events = [domainEvent];
     const allSignals = [];
@@ -13323,7 +13191,7 @@ function planTasksToGeneratedTasks(plan) {
 }
 function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, config, sessionId, worktreePath, onSessionName) {
   return Stream7.unwrap(
-    Effect25.gen(function* () {
+    Effect26.gen(function* () {
       const startTimeUtc = yield* DateTime8.now;
       const startTime = DateTime8.toEpochMillis(startTimeUtc);
       const persistenceStateRef = yield* Ref10.make({
@@ -13351,7 +13219,7 @@ function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, con
         ),
         Stream7.flatMap(
           (llmEvent) => Stream7.unwrap(
-            Effect25.gen(function* () {
+            Effect26.gen(function* () {
               const now = yield* DateTime8.now;
               const context = {
                 timestamp: DateTime8.toEpochMillis(now)
@@ -13391,7 +13259,7 @@ function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, con
         )
       );
       const completionStream = Stream7.fromEffect(
-        Effect25.gen(function* () {
+        Effect26.gen(function* () {
           const persistEvents = yield* flushPlanPersistence(
             planStore,
             currentPlanRef,
@@ -13402,12 +13270,12 @@ function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, con
           if (plan && plan.tasks.length > 0) {
             const generatedTasks = planTasksToGeneratedTasks(plan);
             yield* writeTasksMd(sessionId, generatedTasks).pipe(
-              Effect25.tapError(
-                (error) => Effect25.logDebug("Failed to write tasks.md, continuing", {
+              Effect26.tapError(
+                (error) => Effect26.logDebug("Failed to write tasks.md, continuing", {
                   error: String(error)
                 })
               ),
-              Effect25.orElseSucceed(() => void 0)
+              Effect26.orElseSucceed(() => void 0)
             );
           }
           const endTimeUtc = yield* DateTime8.now;
@@ -13417,8 +13285,8 @@ function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, con
           if (capturedName) {
             if (onSessionName) {
               yield* onSessionName(capturedName).pipe(
-                Effect25.tapError(
-                  (error) => Effect25.logDebug(
+                Effect26.tapError(
+                  (error) => Effect26.logDebug(
                     "Failed to handle session name, continuing",
                     {
                       error: String(error),
@@ -13426,7 +13294,7 @@ function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, con
                     }
                   )
                 ),
-                Effect25.orElseSucceed(() => void 0)
+                Effect26.orElseSucceed(() => void 0)
               );
             }
             const sessionNameEvent = {
@@ -13458,15 +13326,15 @@ function createDiscoveryStream(llm, signalParser, planStore, currentPlanRef, con
 
 // src/orchestrator/iteration.ts
 init_esm_shims();
-import { DateTime as DateTime9, Effect as Effect26, pipe as pipe2, Ref as Ref11, Stream as Stream8 } from "effect";
+import { DateTime as DateTime9, Effect as Effect27, pipe as pipe2, Ref as Ref11, Stream as Stream8 } from "effect";
 function processTextSignals2(signalParser, text, context) {
-  return Effect26.gen(function* () {
+  return Effect27.gen(function* () {
     const events = [];
     let completed = false;
     const parsedSignals = [];
     const signals = yield* signalParser.parse(text).pipe(
-      Effect26.tapError(
-        (error) => Effect26.logDebug(
+      Effect27.tapError(
+        (error) => Effect27.logDebug(
           "Signal parsing failed, continuing with empty signals",
           {
             error: String(error),
@@ -13474,7 +13342,7 @@ function processTextSignals2(signalParser, text, context) {
           }
         )
       ),
-      Effect26.orElseSucceed(() => [])
+      Effect27.orElseSucceed(() => [])
     );
     for (const signal of signals) {
       events.push(mapSignalToDomain(signal, context));
@@ -13487,7 +13355,7 @@ function processTextSignals2(signalParser, text, context) {
   });
 }
 function processLLMEvent2(signalParser, llmEvent, context) {
-  return Effect26.gen(function* () {
+  return Effect27.gen(function* () {
     const domainEvent = mapLLMEventToDomain(llmEvent, context);
     const events = [domainEvent];
     let completed = false;
@@ -13520,7 +13388,7 @@ function processLLMEvent2(signalParser, llmEvent, context) {
 }
 function createIterationStream(llm, signalParser, planStore, currentPlanRef, loopCompletedRef, config, iteration, sessionId, worktreePath) {
   return Stream8.unwrap(
-    Effect26.gen(function* () {
+    Effect27.gen(function* () {
       const currentPlan = yield* Ref11.get(currentPlanRef);
       const persistenceStateRef = yield* Ref11.make({
         dirty: false,
@@ -13543,7 +13411,7 @@ function createIterationStream(llm, signalParser, planStore, currentPlanRef, loo
         ),
         Stream8.flatMap(
           (llmEvent) => Stream8.unwrap(
-            Effect26.gen(function* () {
+            Effect27.gen(function* () {
               const now = yield* DateTime9.now;
               const context = {
                 timestamp: DateTime9.toEpochMillis(now)
@@ -13565,14 +13433,14 @@ function createIterationStream(llm, signalParser, planStore, currentPlanRef, loo
                 events.push(...planEvents);
               }
               if (result.completed) {
-                yield* Effect26.logInfo(
+                yield* Effect27.logInfo(
                   "[DEBUG] createIterationStream: LLM emitted completion signal"
                 );
                 yield* Ref11.set(loopCompletedRef, true);
               }
               const updatedPlan = yield* Ref11.get(currentPlanRef);
               const allComplete = areAllTasksComplete(updatedPlan);
-              yield* Effect26.logInfo(
+              yield* Effect27.logInfo(
                 "[DEBUG] createIterationStream: Auto-complete check",
                 {
                   llmEmittedComplete: result.completed,
@@ -13584,7 +13452,7 @@ function createIterationStream(llm, signalParser, planStore, currentPlanRef, loo
                 }
               );
               if (allComplete) {
-                yield* Effect26.logInfo(
+                yield* Effect27.logInfo(
                   "[DEBUG] createIterationStream: All tasks complete - ending loop"
                 );
                 yield* Ref11.set(loopCompletedRef, true);
@@ -13606,7 +13474,7 @@ function createIterationStream(llm, signalParser, planStore, currentPlanRef, loo
         )
       );
       const completionStream = Stream8.fromEffect(
-        Effect26.gen(function* () {
+        Effect27.gen(function* () {
           const persistEvents = yield* flushPlanPersistence(
             planStore,
             currentPlanRef,
@@ -13631,14 +13499,14 @@ function createIterationStream(llm, signalParser, planStore, currentPlanRef, loo
 // src/orchestrator/loop.ts
 function runLoop(config) {
   return Stream9.unwrap(
-    Effect27.gen(function* () {
+    Effect28.gen(function* () {
       const llm = yield* LLM;
       const signalParser = yield* SignalParser;
       const sessionStore = yield* SessionStore;
       const planStore = yield* PlanStore;
       const git = yield* Git;
       const session = yield* sessionStore.create(config.task).pipe(
-        Effect27.mapError(
+        Effect28.mapError(
           (e) => new OrchestratorError({
             message: `Failed to create session: ${e.message}`,
             phase: "setup",
@@ -13647,15 +13515,15 @@ function runLoop(config) {
         )
       );
       const baseBranch = yield* git.getCurrentBranch().pipe(
-        Effect27.tapError(
-          (error) => Effect27.logDebug("Failed to get current branch", {
+        Effect28.tapError(
+          (error) => Effect28.logDebug("Failed to get current branch", {
             error: String(error)
           })
         ),
-        Effect27.orElseSucceed(() => void 0)
+        Effect28.orElseSucceed(() => void 0)
       );
       const worktreePath = yield* git.createWorktree(session.id).pipe(
-        Effect27.mapError(
+        Effect28.mapError(
           (e) => new OrchestratorError({
             message: `Failed to create worktree: ${e.message}`,
             phase: "setup",
@@ -13670,12 +13538,12 @@ function runLoop(config) {
         branchName,
         baseBranch
       }).pipe(
-        Effect27.tapError(
-          (error) => Effect27.logDebug("Failed to update session with worktree info", {
+        Effect28.tapError(
+          (error) => Effect28.logDebug("Failed to update session with worktree info", {
             error: String(error)
           })
         ),
-        Effect27.orElseSucceed(() => void 0)
+        Effect28.orElseSucceed(() => void 0)
       );
       const startTimeUtc = yield* DateTime10.now;
       const startTime = DateTime10.toEpochMillis(startTimeUtc);
@@ -13696,7 +13564,7 @@ function runLoop(config) {
         config,
         timestamp: startTime
       };
-      const handleSessionName = (displayName) => Effect27.gen(function* () {
+      const handleSessionName = (displayName) => Effect28.gen(function* () {
         const currentSession = yield* Ref12.get(sessionRef);
         const newBranchName = yield* git.renameBranch(
           session.id,
@@ -13722,7 +13590,7 @@ function runLoop(config) {
       );
       const iterationsStream = Stream9.unfoldEffect(
         1,
-        (iteration) => Effect27.gen(function* () {
+        (iteration) => Effect28.gen(function* () {
           const completed = yield* Ref12.get(loopCompletedRef);
           if (completed || iteration > maxIterations) {
             return Option.none();
@@ -13768,8 +13636,8 @@ function runLoop(config) {
       );
     }).pipe(
       // Also catch setup errors (e.g., session creation failure)
-      Effect27.catchAll(
-        (error) => Effect27.succeed(
+      Effect28.catchAll(
+        (error) => Effect28.succeed(
           Stream9.succeed({
             _tag: "LoopFailed",
             error: {
@@ -13795,32 +13663,32 @@ Generated by Ferix`;
 }
 function createCompletionStream(sessionStore, git, sessionRef, config, startTime, loopCompletedRef, _worktreePath) {
   return Stream9.unwrap(
-    Effect27.gen(function* () {
+    Effect28.gen(function* () {
       const session = yield* Ref12.get(sessionRef);
       const endTimeUtc = yield* DateTime10.now;
       const endTime = DateTime10.toEpochMillis(endTimeUtc);
       const durationMs = endTime - startTime;
       const completed = yield* Ref12.get(loopCompletedRef);
       yield* git.commitChanges(session.id, `feat: complete session ${session.id}`).pipe(
-        Effect27.tapError(
-          (error) => Effect27.logDebug("Final commit failed, continuing", {
+        Effect28.tapError(
+          (error) => Effect28.logDebug("Final commit failed, continuing", {
             sessionId: session.id,
             error: String(error)
           })
         ),
-        Effect27.orElseSucceed(() => void 0)
+        Effect28.orElseSucceed(() => void 0)
       );
       let branchPushed = false;
       if (config.push === true) {
         const pushResult = yield* git.pushBranch(session.id).pipe(
-          Effect27.map(() => true),
-          Effect27.tapError(
-            (error) => Effect27.logDebug("Push failed, continuing", {
+          Effect28.map(() => true),
+          Effect28.tapError(
+            (error) => Effect28.logDebug("Push failed, continuing", {
               sessionId: session.id,
               error: String(error)
             })
           ),
-          Effect27.orElseSucceed(() => false)
+          Effect28.orElseSucceed(() => false)
         );
         branchPushed = pushResult;
       }
@@ -13829,25 +13697,25 @@ function createCompletionStream(sessionStore, git, sessionRef, config, startTime
         const title = `feat: ${session.originalTask.slice(0, 50)}`;
         const body = buildPRBody(session, config);
         const prResult = yield* git.createPR(session.id, title, body, session.baseBranch).pipe(
-          Effect27.map((url) => url),
-          Effect27.tapError(
-            (error) => Effect27.logDebug("PR creation failed, continuing", {
+          Effect28.map((url) => url),
+          Effect28.tapError(
+            (error) => Effect28.logDebug("PR creation failed, continuing", {
               sessionId: session.id,
               error: String(error)
             })
           ),
-          Effect27.orElseSucceed(() => void 0)
+          Effect28.orElseSucceed(() => void 0)
         );
         prUrl = prResult;
       }
       yield* git.removeWorktreeKeepBranch(session.id).pipe(
-        Effect27.tapError(
-          (error) => Effect27.logDebug("Worktree cleanup failed, continuing", {
+        Effect28.tapError(
+          (error) => Effect28.logDebug("Worktree cleanup failed, continuing", {
             sessionId: session.id,
             error: String(error)
           })
         ),
-        Effect27.orElseSucceed(() => void 0)
+        Effect28.orElseSucceed(() => void 0)
       );
       const worktreeRemoved = {
         _tag: "WorktreeRemoved",
@@ -13868,13 +13736,13 @@ function createCompletionStream(sessionStore, git, sessionRef, config, startTime
         status: completed ? "completed" : "paused",
         worktreePath: void 0
       }).pipe(
-        Effect27.tapError(
-          (error) => Effect27.logDebug("Session update failed, continuing", {
+        Effect28.tapError(
+          (error) => Effect28.logDebug("Session update failed, continuing", {
             sessionId: session.id,
             error: String(error)
           })
         ),
-        Effect27.orElseSucceed(() => void 0)
+        Effect28.orElseSucceed(() => void 0)
       );
       const events = [worktreeRemoved];
       if (branchPushed) {
@@ -13904,7 +13772,7 @@ function createCompletionStream(sessionStore, git, sessionRef, config, startTime
 function run(options) {
   const { config, consumer: consumerType = "headless", onEvent } = options;
   const events = runLoop(config);
-  const eventsWithCallback = onEvent ? events.pipe(Stream10.tap((event) => Effect28.sync(() => onEvent(event)))) : events;
+  const eventsWithCallback = onEvent ? events.pipe(Stream10.tap((event) => Effect29.sync(() => onEvent(event)))) : events;
   const layers = config.provider ? createProductionLayers(config.provider) : ProductionLayers;
   const eventsWithLayers = eventsWithCallback.pipe(Stream10.provideLayer(layers));
   if (consumerType === "none") {
@@ -13916,7 +13784,7 @@ function run(options) {
 function runTest(options, mockEvents) {
   const { config, onEvent } = options;
   const events = runLoop(config);
-  const eventsWithCallback = onEvent ? events.pipe(Stream10.tap((event) => Effect28.sync(() => onEvent(event)))) : events;
+  const eventsWithCallback = onEvent ? events.pipe(Stream10.tap((event) => Effect29.sync(() => onEvent(event)))) : events;
   const layers = mockEvents ? createTestLayers(mockEvents) : TestLayers;
   const eventsWithLayers = eventsWithCallback.pipe(Stream10.provideLayer(layers));
   return eventsWithLayers.pipe(Stream10.runDrain);
@@ -13924,11 +13792,11 @@ function runTest(options, mockEvents) {
 function collectEvents(config, mockEvents) {
   const events = runLoop(config);
   const layers = mockEvents ? createTestLayers(mockEvents) : TestLayers;
-  return events.pipe(Stream10.provideLayer(layers), Stream10.runCollect).pipe(Effect28.map((chunk) => Array.from(chunk)));
+  return events.pipe(Stream10.provideLayer(layers), Stream10.runCollect).pipe(Effect29.map((chunk) => Array.from(chunk)));
 }
 function main(config) {
   const consumerType = process.stdout.isTTY ? "tui" : "headless";
-  return run({ config, consumer: consumerType }).pipe(Effect28.runPromise);
+  return run({ config, consumer: consumerType }).pipe(Effect29.runPromise);
 }
 
 // src/services/index.ts
@@ -13954,55 +13822,418 @@ program.command("run", { isDefault: true }).argument("<task>", "Task description
     process.exit(1);
   }
 });
-program.command("sync").description("Discover and install skills based on your dependencies").option("-p, --path <path>", "Path to package.json", "./package.json").option("-n, --dry-run", "List skills without installing").option("-g, --global", "Install globally instead of project-level").option("-d, --dev", "Use development server instead of production").action(async (options) => {
+var NON_NPM_VERSION_PREFIXES2 = ["workspace:", "file:", "link:", "portal:"];
+var isNonNpmDependency = (version2) => NON_NPM_VERSION_PREFIXES2.some((prefix) => version2.startsWith(prefix));
+var extractDependencies = (pkg) => {
+  const deps = pkg.dependencies ?? {};
+  const devDeps = pkg.devDependencies ?? {};
+  const allDeps = /* @__PURE__ */ new Map();
+  for (const [name, version2] of Object.entries(deps)) {
+    if (!isNonNpmDependency(version2)) {
+      allDeps.set(name, version2);
+    }
+  }
+  for (const [name, version2] of Object.entries(devDeps)) {
+    if (!(allDeps.has(name) || isNonNpmDependency(version2))) {
+      allDeps.set(name, version2);
+    }
+  }
+  return Array.from(allDeps.keys());
+};
+var extractWorkspacePatterns = (pkg) => {
+  const workspaces = pkg.workspaces;
+  if (!workspaces) {
+    return [];
+  }
+  if (Array.isArray(workspaces)) {
+    return workspaces.filter((w) => typeof w === "string");
+  }
+  if (typeof workspaces === "object" && "packages" in workspaces) {
+    const packages = workspaces.packages;
+    if (Array.isArray(packages)) {
+      return packages.filter((w) => typeof w === "string");
+    }
+  }
+  return [];
+};
+var GLOB_SUFFIX_PATTERN = /\/\*+$/;
+var expandGlobPattern = async (rootDir, pattern) => {
+  if (pattern.endsWith("/*") || pattern.endsWith("/**")) {
+    const baseDir = pattern.replace(GLOB_SUFFIX_PATTERN, "");
+    const fullPath2 = join8(rootDir, baseDir);
+    try {
+      const entries = await readdir2(fullPath2, { withFileTypes: true });
+      return entries.filter((entry) => entry.isDirectory()).map((entry) => join8(fullPath2, entry.name));
+    } catch {
+      return [];
+    }
+  }
+  const fullPath = join8(rootDir, pattern);
   try {
-    console.log("\nScanning for package.json files...");
-    const result = await Effect29.runPromise(
-      sync(options.path, {
-        dryRun: options.dryRun ?? false,
-        global: options.global ?? false,
-        dev: options.dev ?? false
-      })
-    );
-    if (options.dev) {
-      console.log(pc17.yellow("Using development server"));
+    await access4(fullPath);
+    return [fullPath];
+  } catch {
+    return [];
+  }
+};
+var readPackageJsonFile = async (filePath) => {
+  const content = await readFile7(filePath, "utf-8");
+  return JSON.parse(content);
+};
+var discoverPackageJsonFiles = async (rootPath, rootPkg) => {
+  const rootDir = dirname2(rootPath);
+  const patterns = extractWorkspacePatterns(rootPkg);
+  if (patterns.length === 0) {
+    return [rootPath];
+  }
+  const packageJsonPaths = [rootPath];
+  for (const pattern of patterns) {
+    const dirs = await expandGlobPattern(rootDir, pattern);
+    for (const dir of dirs) {
+      const pkgPath = join8(dir, "package.json");
+      try {
+        await access4(pkgPath);
+        packageJsonPaths.push(pkgPath);
+      } catch {
+      }
     }
-    const packageMsg = result.packageJsonCount > 1 ? `Found ${pc17.bold(String(result.packageJsonCount))} package.json files (monorepo)` : "Found 1 package.json file";
-    console.log(packageMsg);
-    console.log(
-      `Found ${pc17.bold(String(result.dependencies.length))} dependencies (deduplicated)`
-    );
-    console.log(
-      `Resolved ${pc17.bold(String(result.orgs.length))} unique GitHub organizations`
+  }
+  return packageJsonPaths;
+};
+var SYMBOLS = {
+  success: pc17.green("\u2713"),
+  error: pc17.red("\u2717")
+};
+var printHeader = (title, subtitle) => {
+  console.log();
+  console.log(pc17.bold(pc17.cyan(`  ${title}`)));
+  if (subtitle) {
+    console.log(pc17.dim(`  ${subtitle}`));
+  }
+  console.log();
+};
+var printSection = (title) => {
+  console.log();
+  console.log(pc17.bold(`  ${title}`));
+};
+var printRepo = (owner, repo, index) => {
+  const num = pc17.dim(`${String(index + 1).padStart(2, " ")}.`);
+  console.log(`  ${num} ${pc17.cyan(owner)}${pc17.dim("/")}${pc17.white(repo)}`);
+};
+var printSuccess = (message) => {
+  console.log(`  ${SYMBOLS.success} ${pc17.green(message)}`);
+};
+var printError = (message) => {
+  console.log(`  ${SYMBOLS.error} ${pc17.red(message)}`);
+};
+var printHint = (message) => {
+  console.log(pc17.dim(`  ${message}`));
+};
+var createSpinner = (text) => {
+  return ora({
+    text,
+    prefixText: " ",
+    spinner: "dots"
+  });
+};
+var discoverPackages = async (state, packagePath) => {
+  state.spinner = createSpinner("Scanning for package.json files...").start();
+  const absolutePath = resolve(packagePath);
+  await access4(absolutePath);
+  const rootPkg = await readPackageJsonFile(absolutePath);
+  state.packageJsonPaths = await discoverPackageJsonFiles(
+    absolutePath,
+    rootPkg
+  );
+  const isMonorepo = state.packageJsonPaths.length > 1;
+  state.spinner.succeed(
+    isMonorepo ? `Found ${pc17.bold(String(state.packageJsonPaths.length))} package.json files ${pc17.dim("(monorepo)")}` : "Found package.json"
+  );
+  return true;
+};
+var extractAllDependencies = async (state) => {
+  state.spinner = createSpinner("Extracting dependencies...").start();
+  const allDependencies = /* @__PURE__ */ new Set();
+  for (const pkgPath of state.packageJsonPaths) {
+    const pkg = await readPackageJsonFile(pkgPath);
+    for (const dep of extractDependencies(pkg)) {
+      allDependencies.add(dep);
+    }
+  }
+  state.dependencies = Array.from(allDependencies);
+  if (state.dependencies.length === 0) {
+    state.spinner.warn("No dependencies found");
+    return false;
+  }
+  state.spinner.succeed(
+    `Found ${pc17.bold(String(state.dependencies.length))} unique dependencies`
+  );
+  return true;
+};
+var resolveOrganizations = async (state, isDev) => {
+  state.spinner = createSpinner("Resolving GitHub organizations...").start();
+  const packageOrgs = await Effect30.runPromise(
+    resolvePackageOrgs(state.dependencies, isDev)
+  );
+  state.orgs = Array.from(
+    new Set(
+      packageOrgs.map((p) => p.githubOrg).filter((org) => org !== null)
+    )
+  );
+  if (state.orgs.length === 0) {
+    state.spinner.warn("No GitHub organizations found");
+    printHint("Your dependencies don't have linked GitHub organizations.");
+    return false;
+  }
+  state.spinner.succeed(
+    `Resolved ${pc17.bold(String(state.orgs.length))} GitHub organizations`
+  );
+  return true;
+};
+var findRepositories = async (state, isDev) => {
+  state.spinner = createSpinner("Searching for skill repositories...").start();
+  state.skillRepos = await Effect30.runPromise(findSkillRepos(state.orgs, isDev));
+  if (state.skillRepos.length === 0) {
+    state.spinner.warn("No skill repositories found");
+    printHint(
+      "None of your dependency organizations have published skills yet."
     );
-    if (result.skillRepos.length === 0) {
-      console.log(
-        `
-${pc17.yellow("No skill repositories found for your dependencies.")}`
+    return false;
+  }
+  state.spinner.succeed(
+    `Found ${pc17.bold(String(state.skillRepos.length))} skill ${state.skillRepos.length === 1 ? "repository" : "repositories"}`
+  );
+  return true;
+};
+var selectRepositories = async (skillRepos) => {
+  if (skillRepos.length === 1) {
+    const repo = skillRepos[0];
+    if (repo) {
+      printHint(
+        `Only 1 repository found, auto-selecting: ${pc17.cyan(`${repo.owner}/${repo.repo}`)}`
       );
-      return;
     }
-    console.log(
-      `
-Found ${pc17.bold(String(result.skillRepos.length))} skill repositories:
-`
+    return { type: "selected", repos: skillRepos };
+  }
+  if (!process.stdin.isTTY) {
+    printHint(
+      `Non-interactive terminal detected, selecting all ${skillRepos.length} repositories.`
     );
-    for (const repo of result.skillRepos) {
-      console.log(`  ${pc17.green("\u2022")} ${repo.owner}/${repo.repo}`);
-    }
-    if (options.dryRun) {
-      console.log(
-        `
-${pc17.dim("Run without --dry-run to install these skills.")}`
+    printHint(`Use ${pc17.cyan("--yes")} flag to skip this message in CI/CD.`);
+    return { type: "selected", repos: skillRepos };
+  }
+  console.log();
+  const selected = await multiselect({
+    message: "Select repositories to install (space to toggle, a to toggle all)",
+    options: skillRepos.map((repo) => ({
+      value: repo,
+      label: `${repo.owner}/${repo.repo}`
+    })),
+    required: false
+  });
+  if (isCancel(selected)) {
+    return { type: "cancelled" };
+  }
+  if (selected.length === 0) {
+    return { type: "none" };
+  }
+  return { type: "selected", repos: selected };
+};
+var installRepositories = async (state, reposToInstall, isGlobal, agents) => {
+  printSection("Installing");
+  console.log();
+  const installed = [];
+  const failed = [];
+  for (const repo of reposToInstall) {
+    const repoId = `${repo.owner}/${repo.repo}`;
+    state.spinner = createSpinner(
+      `Installing ${pc17.cyan(repo.owner)}${pc17.dim("/")}${pc17.white(repo.repo)}...`
+    ).start();
+    try {
+      await Effect30.runPromise(
+        installSkills([repo], {
+          dryRun: false,
+          global: isGlobal,
+          agents: [...agents]
+        })
       );
-    } else {
-      console.log(
-        `
-${pc17.green("\u2713")} Installed ${pc17.bold(String(result.installed.length))} skill repositories`
+      state.spinner.succeed(
+        `Installed ${pc17.cyan(repo.owner)}${pc17.dim("/")}${pc17.white(repo.repo)}`
+      );
+      installed.push(repoId);
+    } catch {
+      state.spinner.fail(
+        `Failed to install ${pc17.cyan(repo.owner)}${pc17.dim("/")}${pc17.white(repo.repo)}`
       );
+      failed.push(repoId);
     }
+  }
+  return { installed, failed };
+};
+var displaySummary = (installed, failed, isGlobal, agents) => {
+  printSection("Summary");
+  console.log();
+  if (installed.length > 0) {
+    printSuccess(
+      `${installed.length} skill ${installed.length === 1 ? "repository" : "repositories"} installed successfully`
+    );
+  }
+  if (failed.length > 0) {
+    printError(
+      `${failed.length} ${failed.length === 1 ? "installation" : "installations"} failed`
+    );
+  }
+  const installLocation = isGlobal ? "globally" : "in project";
+  const agentList = agents.length > 0 ? agents.join(", ") : "all agents";
+  printHint(`Skills installed ${installLocation} to: ${pc17.cyan(agentList)}`);
+  console.log();
+};
+var detectProjectAgents = async (state, projectDir) => {
+  state.spinner = createSpinner("Detecting coding agents...").start();
+  state.detectedAgents = await Effect30.runPromise(detectAgents(projectDir));
+  if (state.detectedAgents.length === 0) {
+    state.spinner.warn("No coding agents detected");
+    printHint(
+      `No agent directories found (${pc17.dim(".cursor/, .claude/, .opencode/, etc.")})`
+    );
+    printHint(
+      `Use ${pc17.cyan("--agents")} to specify agents manually, e.g. ${pc17.cyan("--agents cursor claude-code")}`
+    );
+    return false;
+  }
+  state.spinner.succeed(
+    `Detected agents: ${pc17.cyan(state.detectedAgents.join(", "))}`
+  );
+  return true;
+};
+var determineAgents = async (state, packagePath, manualAgents) => {
+  if (manualAgents && manualAgents.length > 0) {
+    const invalidAgents = validateAgentNames(manualAgents);
+    if (invalidAgents.length > 0) {
+      printError(`Invalid agent names: ${invalidAgents.join(", ")}`);
+      printHint(`Supported agents: ${SUPPORTED_AGENTS.join(", ")}`);
+      console.log();
+      return null;
+    }
+    printSuccess(`Using specified agents: ${pc17.cyan(manualAgents.join(", "))}`);
+    return manualAgents;
+  }
+  const projectDir = dirname2(resolve(packagePath));
+  const hasAgents = await detectProjectAgents(state, projectDir);
+  return hasAgents ? state.detectedAgents : null;
+};
+var handleRepoSelection = async (skillRepos, skipSelection) => {
+  if (skipSelection) {
+    printSuccess(
+      `Auto-selecting all ${skillRepos.length} repositories (--yes)`
+    );
+    return skillRepos;
+  }
+  const selection = await selectRepositories(skillRepos);
+  if (selection.type === "cancelled") {
+    cancel("Operation cancelled.");
+    process.exit(0);
+  }
+  if (selection.type === "none") {
+    console.log();
+    printHint("No repositories selected. Skipping installation.");
+    console.log();
+    return null;
+  }
+  printSuccess(`Selected ${selection.repos.length} repositories`);
+  return selection.repos;
+};
+var displayDryRunSummary = (reposToInstall, agentsToUse) => {
+  console.log();
+  printSection("Would install");
+  console.log();
+  for (let i = 0; i < reposToInstall.length; i++) {
+    const repo = reposToInstall[i];
+    if (repo) {
+      printRepo(repo.owner, repo.repo, i);
+    }
+  }
+  console.log();
+  printHint(
+    `Would install to: ${pc17.cyan(agentsToUse.join(", ") || "all agents")}`
+  );
+  printHint(`Run without ${pc17.cyan("--dry-run")} to install these skills.`);
+  console.log();
+};
+var runSyncCommand = async (options) => {
+  const {
+    path: packagePath,
+    dryRun,
+    global: isGlobal,
+    dev: isDev,
+    agents: manualAgents,
+    yes: skipSelection
+  } = options;
+  printHeader(
+    "Ferix Sync",
+    isDev ? pc17.yellow("Development Mode") : "Discovering skills from your dependencies"
+  );
+  const state = {
+    spinner: void 0,
+    packageJsonPaths: [],
+    dependencies: [],
+    orgs: [],
+    skillRepos: [],
+    detectedAgents: []
+  };
+  await discoverPackages(state, packagePath);
+  const agentsToUse = await determineAgents(state, packagePath, manualAgents);
+  if (!agentsToUse) {
+    return;
+  }
+  const hasDeps = await extractAllDependencies(state);
+  if (!hasDeps) {
+    return;
+  }
+  const hasOrgs = await resolveOrganizations(state, isDev);
+  if (!hasOrgs) {
+    return;
+  }
+  const hasRepos = await findRepositories(state, isDev);
+  if (!hasRepos) {
+    return;
+  }
+  const reposToInstall = await handleRepoSelection(
+    state.skillRepos,
+    skipSelection
+  );
+  if (!reposToInstall) {
+    return;
+  }
+  if (dryRun) {
+    displayDryRunSummary(reposToInstall, agentsToUse);
+    return;
+  }
+  const { installed, failed } = await installRepositories(
+    state,
+    reposToInstall,
+    isGlobal,
+    agentsToUse
+  );
+  displaySummary(installed, failed, isGlobal, agentsToUse);
+};
+program.command("sync").description("Discover and install skills based on your dependencies").option("-p, --path <path>", "Path to package.json", "./package.json").option("-n, --dry-run", "List skills without installing").option("-g, --global", "Install globally instead of project-level").option("-d, --dev", "Use development server instead of production").option(
+  "-a, --agents <agents...>",
+  "Specify agents to install to (auto-detects if not provided)"
+).option("-y, --yes", "Skip selection prompt, install all repositories").action(async (options) => {
+  try {
+    await runSyncCommand({
+      path: options.path,
+      dryRun: options.dryRun ?? false,
+      global: options.global ?? false,
+      dev: options.dev ?? false,
+      agents: options.agents,
+      yes: options.yes ?? false
+    });
   } catch (error) {
-    console.error(pc17.red("Error:"), error);
+    console.log();
+    printError(error instanceof Error ? error.message : String(error));
+    console.log();
     process.exit(1);
   }
 });