@looplia/looplia-cli 0.7.5 → 0.8.0

package/dist/{chunk-GIZRTNY3.js → chunk-RAFHASLI.js}

@@ -1,298 +1,17 @@
 #!/usr/bin/env bun
 import {
-  __dirname,
+  getLoopliaPluginPath,
+  getPluginPaths,
+  getSelectivePluginPaths
+} from "./chunk-JJCGDGRS.js";
+import {
   pathExists
-} from "./chunk-VRBGWKZ6.js";
+} from "./chunk-326UJHZM.js";
 import {
   __export,
   init_esm_shims
 } from "./chunk-Y55L47HC.js";
 
-// ../../packages/provider/dist/chunk-5BLYIGE4.js
-init_esm_shims();
-import { createHash } from "crypto";
-import {
-  cp,
-  mkdir as mkdir2,
-  readdir as readdir2,
-  readFile,
-  realpath,
-  rm,
-  writeFile
-} from "fs/promises";
-import { homedir as homedir2, tmpdir } from "os";
-import { dirname, join as join2 } from "path";
-import { fileURLToPath } from "url";
-import { exec } from "child_process";
-import { mkdir, readdir } from "fs/promises";
-import { join } from "path";
-import { promisify } from "util";
-var execAsync = promisify(exec);
-var CORE_SKILLS = [
-  "workflow-executor",
-  "workflow-validator",
-  "registry-loader"
-];
-async function buildSkillPluginMap(pluginPaths) {
-  const map = /* @__PURE__ */ new Map();
-  for (const { path: pluginPath } of pluginPaths) {
-    const skillsDir = join(pluginPath, "skills");
-    if (!await pathExists(skillsDir)) {
-      continue;
-    }
-    try {
-      const entries = await readdir(skillsDir, { withFileTypes: true });
-      for (const entry of entries) {
-        if (entry.isDirectory()) {
-          map.set(entry.name, pluginPath);
-        }
-      }
-    } catch {
-    }
-  }
-  return map;
-}
-async function getSelectivePluginPaths(requiredSkills) {
-  const allPluginPaths = await getPluginPaths();
-  if (!requiredSkills || requiredSkills.length === 0) {
-    return allPluginPaths;
-  }
-  const neededSkills = /* @__PURE__ */ new Set([...CORE_SKILLS, ...requiredSkills]);
-  const skillToPlugin = await buildSkillPluginMap(allPluginPaths);
-  const pluginsToLoad = /* @__PURE__ */ new Set();
-  for (const skill of neededSkills) {
-    const pluginPath = skillToPlugin.get(skill);
-    if (pluginPath) {
-      pluginsToLoad.add(pluginPath);
-    }
-  }
-  return allPluginPaths.filter((p) => pluginsToLoad.has(p.path));
-}
-function isCoreSkill(skillName) {
-  return CORE_SKILLS.includes(skillName);
-}
-async function computeSha256(filePath) {
-  const content = await readFile(filePath);
-  return createHash("sha256").update(content).digest("hex");
-}
-async function validateExtractedPaths(baseDir) {
-  const realBase = await realpath(baseDir);
-  const entries = await readdir2(baseDir, { withFileTypes: true });
-  for (const entry of entries) {
-    const fullPath = join2(baseDir, entry.name);
-    const entryRealPath = await realpath(fullPath);
-    if (!entryRealPath.startsWith(realBase)) {
-      throw new Error(
-        `Security: Path traversal detected in extracted file: ${entry.name}`
-      );
-    }
-    if (entry.isDirectory()) {
-      await validateExtractedPaths(fullPath);
-    }
-  }
-}
-function getLoopliaPluginPath() {
-  return process.env.LOOPLIA_HOME ?? join2(homedir2(), ".looplia");
-}
-function getBundledPluginsPath() {
-  const currentFile = typeof __dirname !== "undefined" ? __dirname : dirname(fileURLToPath(import.meta.url));
-  return join2(currentFile, "..", "..", "plugins");
-}
-async function parseMarketplace(marketplacePath) {
-  const content = await readFile(marketplacePath, "utf-8");
-  return JSON.parse(content);
-}
-async function getPluginNamesFromSource(bundledPath) {
-  const marketplacePath = join2(
-    bundledPath,
-    "..",
-    ".claude-plugin",
-    "marketplace.json"
-  );
-  if (await pathExists(marketplacePath)) {
-    const marketplace = await parseMarketplace(marketplacePath);
-    return marketplace.plugins.map((p) => {
-      const parts = p.source.split("/");
-      return parts.at(-1);
-    }).filter((name) => name !== void 0);
-  }
-  const entries = await readdir2(bundledPath, { withFileTypes: true });
-  return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name);
-}
-function createDefaultProfile() {
-  return {
-    userId: "default",
-    topics: [],
-    style: {
-      tone: "intermediate",
-      targetWordCount: 1e3,
-      voice: "first-person"
-    }
-  };
-}
-async function extractWorkflows(targetDir, pluginNames) {
-  const workflowsDir = join2(targetDir, "workflows");
-  await mkdir2(workflowsDir, { recursive: true });
-  for (const pluginName of pluginNames) {
-    const pluginWorkflowsPath = join2(targetDir, pluginName, "workflows");
-    if (!await pathExists(pluginWorkflowsPath)) {
-      continue;
-    }
-    const entries = await readdir2(pluginWorkflowsPath, { withFileTypes: true });
-    for (const entry of entries) {
-      if (entry.isFile() && entry.name.endsWith(".md")) {
-        await cp(
-          join2(pluginWorkflowsPath, entry.name),
-          join2(workflowsDir, entry.name)
-        );
-      }
-    }
-    await rm(pluginWorkflowsPath, { recursive: true, force: true });
-  }
-}
-async function copyPlugins(targetDir, sourcePath) {
-  const bundledPath = sourcePath ?? getBundledPluginsPath();
-  const pluginNames = await getPluginNamesFromSource(bundledPath);
-  if (pluginNames.length === 0) {
-    throw new Error(`No plugins found at ${bundledPath}`);
-  }
-  if (await pathExists(targetDir)) {
-    await rm(targetDir, { recursive: true, force: true });
-  }
-  await mkdir2(targetDir, { recursive: true });
-  for (const pluginName of pluginNames) {
-    const pluginPath = join2(bundledPath, pluginName);
-    if (await pathExists(pluginPath)) {
-      await cp(pluginPath, join2(targetDir, pluginName), { recursive: true });
-    }
-  }
-  await extractWorkflows(targetDir, pluginNames);
-  await mkdir2(join2(targetDir, "sandbox"), { recursive: true });
-  await writeFile(
-    join2(targetDir, "user-profile.json"),
-    JSON.stringify(createDefaultProfile(), null, 2),
-    "utf-8"
-  );
-  const { initializeRegistry, compileRegistry } = await import("./compiler-4B63UTUP-VE77VSJ2.js");
-  await initializeRegistry();
-  const { syncRegistrySources } = await import("./sync-E5PGFGNI-IGGJR7IL.js");
-  const syncResults = await syncRegistrySources({ showProgress: true });
-  for (const result of syncResults) {
-    if (result.status === "failed") {
-      console.warn(
-        `Warning: Failed to sync ${result.source.id}: ${result.error}`
-      );
-    }
-  }
-  await compileRegistry();
-}
-async function downloadRemotePlugins(version2, targetDir) {
-  const releaseUrl = version2 === "latest" ? "https://github.com/memorysaver/looplia-core/releases/latest/download/plugins.tar.gz" : `https://github.com/memorysaver/looplia-core/releases/download/${version2}/plugins.tar.gz`;
-  console.log(`Downloading looplia plugins from ${releaseUrl}...`);
-  const tempDir = join2(tmpdir(), `looplia-download-${Date.now()}`);
-  await mkdir2(tempDir, { recursive: true });
-  try {
-    const response = await fetch(releaseUrl);
-    if (!response.ok) {
-      throw new Error(
-        `Failed to download plugins: ${response.status} ${response.statusText}`
-      );
-    }
-    const tarPath = join2(tempDir, "plugins.tar.gz");
-    await writeFile(tarPath, Buffer.from(await response.arrayBuffer()));
-    const checksumUrl = `${releaseUrl}.sha256`;
-    const checksumResponse = await fetch(checksumUrl);
-    if (checksumResponse.ok) {
-      const checksumText = await checksumResponse.text();
-      const checksumParts = checksumText.split(" ");
-      const expectedChecksum = checksumParts[0]?.trim();
-      if (!expectedChecksum) {
-        throw new Error("Invalid checksum file format");
-      }
-      const actualChecksum = await computeSha256(tarPath);
-      if (actualChecksum !== expectedChecksum) {
-        throw new Error(
-          `Checksum verification failed. Expected: ${expectedChecksum}, Got: ${actualChecksum}`
-        );
-      }
-      console.log("\u2713 Checksum verified");
-    } else {
-      console.log(
-        "\u26A0 Checksum file not available (older release), skipping verification"
-      );
-    }
-    const { exec: exec2 } = await import("child_process");
-    const { promisify: promisify2 } = await import("util");
-    const execAsync2 = promisify2(exec2);
-    try {
-      await execAsync2("tar -xzf plugins.tar.gz", { cwd: tempDir });
-    } catch (error2) {
-      const errorMessage = error2 instanceof Error ? error2.message : String(error2);
-      throw new Error(
-        `Failed to extract plugins tarball. Ensure 'tar' is available. Error: ${errorMessage}`
-      );
-    }
-    await rm(tarPath);
-    await validateExtractedPaths(tempDir);
-    await copyPlugins(targetDir, tempDir);
-    console.log(`Plugins downloaded and extracted to ${targetDir}`);
-  } finally {
-    await rm(tempDir, { recursive: true, force: true }).catch(() => {
-    });
-  }
-}
-async function isLoopliaInitialized() {
-  const pluginPath = getLoopliaPluginPath();
-  try {
-    const entries = await readdir2(pluginPath, { withFileTypes: true });
-    return entries.some(
-      (e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "sandbox" && e.name !== "workflows"
-    );
-  } catch {
-    return false;
-  }
-}
-function getDevPluginPaths(projectRoot) {
-  return [
-    { type: "local", path: join2(projectRoot, "plugins", "looplia-core") },
-    { type: "local", path: join2(projectRoot, "plugins", "looplia-writer") }
-  ];
-}
-async function getProdPluginPaths() {
-  const loopliaPath = getLoopliaPluginPath();
-  const results = [];
-  try {
-    const entries = await readdir2(loopliaPath, { withFileTypes: true });
-    const pluginDirs = entries.filter(
-      (e) => e.isDirectory() && !e.name.startsWith(".") && e.name !== "sandbox" && e.name !== "workflows" && e.name !== "plugins" && e.name !== "registry"
-    ).map((e) => e.name);
-    for (const name of pluginDirs) {
-      results.push({ type: "local", path: join2(loopliaPath, name) });
-    }
-  } catch {
-  }
-  const pluginsDir = join2(loopliaPath, "plugins");
-  try {
-    const entries = await readdir2(pluginsDir, { withFileTypes: true });
-    const thirdPartyDirs = entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name);
-    for (const name of thirdPartyDirs) {
-      results.push({ type: "local", path: join2(pluginsDir, name) });
-    }
-  } catch {
-  }
-  return results;
-}
-async function getPluginPaths() {
-  if (process.env.LOOPLIA_HOME) {
-    return await getProdPluginPaths();
-  }
-  if (process.env.LOOPLIA_DEV === "true") {
-    const devRoot = process.env.LOOPLIA_DEV_ROOT ?? process.cwd();
-    return getDevPluginPaths(devRoot);
-  }
-  return await getProdPluginPaths();
-}
-
 // ../../packages/core/dist/index.js
 init_esm_shims();
 
@@ -5036,23 +4755,23 @@ function validateUserProfile(data) {
   return { success: false, error: { message: result.error.message } };
 }
 
-// ../../packages/provider/dist/chunk-W4MDOBYT.js
+// ../../packages/provider/dist/chunk-LJ75DZPB.js
 init_esm_shims();
 import { execSync } from "child_process";
 import { existsSync as existsSync3 } from "fs";
 import { createRequire } from "module";
-import { homedir as homedir3 } from "os";
-import { dirname as dirname3, join as join4 } from "path";
+import { homedir as homedir2 } from "os";
+import { dirname as dirname2, join as join4 } from "path";
 import {
   chmod,
-  mkdir as mkdir3,
-  readFile as readFile2,
+  mkdir,
+  readFile,
   rename,
-  rm as rm2,
-  writeFile as writeFile2
+  rm,
+  writeFile
 } from "fs/promises";
 import { homedir as homedir22 } from "os";
-import { join as join23 } from "path";
+import { join as join22 } from "path";
 
 // ../../node_modules/zod-to-json-schema/dist/esm/index.js
 init_esm_shims();
@@ -6391,7 +6110,7 @@ var zodToJsonSchema = (schema, options) => {
   return combined;
 };
 
-// ../../packages/provider/dist/chunk-W4MDOBYT.js
+// ../../packages/provider/dist/chunk-LJ75DZPB.js
 import { join as join6 } from "path";
 
 // ../../node_modules/@anthropic-ai/claude-agent-sdk/sdk.mjs
@@ -6403,15 +6122,15 @@ import { spawn } from "child_process";
 import { createInterface } from "readline";
 import * as fs from "fs";
 import { stat as statPromise, open } from "fs/promises";
-import { join as join3 } from "path";
+import { join } from "path";
 import { homedir } from "os";
-import { dirname as dirname2, join as join22 } from "path";
+import { dirname, join as join2 } from "path";
 import { cwd } from "process";
 import { realpathSync as realpathSync2 } from "fs";
 import { randomUUID } from "crypto";
 import { randomUUID as randomUUID2 } from "crypto";
 import { appendFileSync as appendFileSync2, existsSync as existsSync2, mkdirSync as mkdirSync2 } from "fs";
-import { join as join32 } from "path";
+import { join as join3 } from "path";
 import { randomUUID as randomUUID3 } from "crypto";
 var __create = Object.create;
 var __getProtoOf = Object.getPrototypeOf;
@@ -13105,7 +12824,7 @@ function shouldShowDebugMessage(message, filter) {
   return shouldShowDebugCategories(categories, filter);
 }
 function getClaudeConfigHomeDir() {
-  return process.env.CLAUDE_CONFIG_DIR ?? join3(homedir(), ".claude");
+  return process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude");
 }
 function isEnvTruthy(envVar) {
   if (!envVar)
@@ -13377,8 +13096,8 @@ function getDebugWriter() {
     debugWriter = createBufferedWriter({
       writeFn: (content) => {
         const path = getDebugLogPath();
-        if (!getFsImplementation().existsSync(dirname2(path))) {
-          getFsImplementation().mkdirSync(dirname2(path));
+        if (!getFsImplementation().existsSync(dirname(path))) {
+          getFsImplementation().mkdirSync(dirname(path));
         }
         getFsImplementation().appendFileSync(path, content);
         updateLatestDebugLogSymlink();
@@ -13411,7 +13130,7 @@ function logForDebugging(message, { level } = {
   getDebugWriter().write(output);
 }
 function getDebugLogPath() {
-  return process.env.CLAUDE_CODE_DEBUG_LOGS_DIR ?? join22(getClaudeConfigHomeDir(), "debug", `${getSessionId()}.txt`);
+  return process.env.CLAUDE_CODE_DEBUG_LOGS_DIR ?? join2(getClaudeConfigHomeDir(), "debug", `${getSessionId()}.txt`);
 }
 var updateLatestDebugLogSymlink = memoize_default(() => {
   if (process.argv[2] === "--ripgrep") {
@@ -13419,8 +13138,8 @@ var updateLatestDebugLogSymlink = memoize_default(() => {
   }
   try {
     const debugLogPath = getDebugLogPath();
-    const debugLogsDir = dirname2(debugLogPath);
-    const latestSymlinkPath = join22(debugLogsDir, "latest");
+    const debugLogsDir = dirname(debugLogPath);
+    const latestSymlinkPath = join2(debugLogsDir, "latest");
     if (!getFsImplementation().existsSync(debugLogsDir)) {
       getFsImplementation().mkdirSync(debugLogsDir);
     }
@@ -13571,8 +13290,8 @@ function getOrCreateDebugFile() {
   if (!process.env.DEBUG_CLAUDE_AGENT_SDK) {
     return null;
   }
-  const debugDir = join32(getClaudeConfigHomeDir(), "debug");
-  debugFilePath = join32(debugDir, `sdk-${randomUUID2()}.txt`);
+  const debugDir = join3(getClaudeConfigHomeDir(), "debug");
+  debugFilePath = join3(debugDir, `sdk-${randomUUID2()}.txt`);
   if (!existsSync2(debugDir)) {
     mkdirSync2(debugDir, { recursive: true });
   }
@@ -22929,19 +22648,20 @@ function query({
   return queryInstance;
 }
 
-// ../../packages/provider/dist/chunk-W4MDOBYT.js
+// ../../packages/provider/dist/chunk-LJ75DZPB.js
 import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync3, writeFileSync } from "fs";
-import { join as join33 } from "path";
-import { access, readdir as readdir3, readFile as readFile22, stat } from "fs/promises";
+import { join as join32 } from "path";
+import { access, readdir, readFile as readFile2, stat } from "fs/promises";
 import { join as join42 } from "path";
-import { cp as cp2, mkdir as mkdir22, readFile as readFile3, rm as rm22, writeFile as writeFile22 } from "fs/promises";
-import { homedir as homedir32 } from "os";
+import { cp, mkdir as mkdir2, readFile as readFile3, rm as rm2, writeFile as writeFile2 } from "fs/promises";
+import { homedir as homedir3 } from "os";
 import { isAbsolute, join as join52, normalize, resolve } from "path";
-import { readdir as readdir22, readFile as readFile4, rename as rename2, stat as stat2, writeFile as writeFile3 } from "fs/promises";
+import { homedir as homedir4 } from "os";
+import { readdir as readdir2, readFile as readFile4, rename as rename2, stat as stat2, writeFile as writeFile3 } from "fs/promises";
 import { join as join7 } from "path";
 import {
   open as open2,
-  readdir as readdir32,
+  readdir as readdir3,
   readFile as readFile5,
   rename as rename3,
   stat as stat3,
@@ -22957,7 +22677,7 @@ function findSdkBundledCliPath() {
     const sdkPackagePath = require2.resolve(
       "@anthropic-ai/claude-agent-sdk/package.json"
     );
-    const sdkDir = dirname3(sdkPackagePath);
+    const sdkDir = dirname2(sdkPackagePath);
     const cliPath = join4(sdkDir, "cli.js");
     if (existsSync3(cliPath)) {
       return cliPath;
@@ -22968,13 +22688,13 @@ function findSdkBundledCliPath() {
 }
 var CLAUDE_CODE_PATHS = [
   // User's local bin (npm global install location)
-  join4(homedir3(), ".local", "bin", "claude"),
+  join4(homedir2(), ".local", "bin", "claude"),
   // System-wide installations
   "/usr/local/bin/claude",
   // macOS Homebrew
   "/opt/homebrew/bin/claude",
   // Windows (if applicable)
-  join4(homedir3(), "AppData", "Local", "Programs", "claude", "claude.exe")
+  join4(homedir2(), "AppData", "Local", "Programs", "claude", "claude.exe")
 ];
 var cachedClaudeCodePath;
 function findClaudeCodePath() {
@@ -23276,15 +22996,15 @@ var PRESETS = {
 };
 var CONFIG_FILE = "looplia.setting.json";
 function getLoopliaHome() {
-  return join23(homedir22(), ".looplia");
+  return join22(homedir22(), ".looplia");
 }
 function getConfigPath() {
-  return join23(getLoopliaHome(), CONFIG_FILE);
+  return join22(getLoopliaHome(), CONFIG_FILE);
 }
 async function readLoopliaSettings() {
   const configPath = getConfigPath();
   try {
-    const content = await readFile2(configPath, "utf-8");
+    const content = await readFile(configPath, "utf-8");
     return JSON.parse(content);
   } catch (error2) {
     if (error2.code === "ENOENT") {
@@ -23292,7 +23012,7 @@ async function readLoopliaSettings() {
     }
     if (error2 instanceof SyntaxError) {
       const backupPath = `${configPath}.corrupted`;
-      await rm2(backupPath, { force: true });
+      await rm(backupPath, { force: true });
       await rename(configPath, backupPath);
       console.warn(
         `Config file corrupted, backed up to ${backupPath}. Using defaults.`
@@ -23304,12 +23024,12 @@ async function readLoopliaSettings() {
 }
 async function writeLoopliaSettings(settings) {
   const configPath = getConfigPath();
-  await mkdir3(getLoopliaHome(), { recursive: true });
-  await writeFile2(configPath, JSON.stringify(settings, null, 2), "utf-8");
+  await mkdir(getLoopliaHome(), { recursive: true });
+  await writeFile(configPath, JSON.stringify(settings, null, 2), "utf-8");
   await chmod(configPath, 384);
 }
 async function removeLoopliaSettings() {
-  await rm2(getConfigPath(), { force: true });
+  await rm(getConfigPath(), { force: true });
 }
 function setEnvIfNotSet(key, value) {
   if (!process.env[key]) {
@@ -23486,10 +23206,10 @@ function createQueryLogger(workspace) {
   let logPath = null;
   return {
     init(sandboxId) {
-      const logsDir = join33(workspace, "sandbox", sandboxId, "logs");
+      const logsDir = join32(workspace, "sandbox", sandboxId, "logs");
       mkdirSync3(logsDir, { recursive: true });
       const filename = generateLogFilename();
-      logPath = join33(logsDir, filename);
+      logPath = join32(logsDir, filename);
       const timestamp = (/* @__PURE__ */ new Date()).toISOString();
       writeFileSync(
         logPath,
@@ -23653,7 +23373,7 @@ function validationError(field, message) {
 }
 async function findMostRecentSandbox(sandboxRoot) {
   try {
-    const entries = await readdir3(sandboxRoot, { withFileTypes: true });
+    const entries = await readdir(sandboxRoot, { withFileTypes: true });
     const dirs = entries.filter(
       (e) => e.isDirectory() && !e.name.startsWith(".")
     );
@@ -23720,7 +23440,7 @@ async function readValidationManifest(sandboxDir) {
       continue;
     }
     try {
-      const content = await readFile22(validationPath, "utf-8");
+      const content = await readFile2(validationPath, "utf-8");
       const parsed = JSON.parse(content);
       if (!isValidationManifest(parsed)) {
         return { error: "Invalid validation manifest structure" };
@@ -23736,7 +23456,7 @@ async function readValidationManifest(sandboxDir) {
 async function readFinalArtifact(sandboxDir, outputPath) {
   const artifactPath = join42(sandboxDir, outputPath);
   try {
-    const content = await readFile22(artifactPath, "utf-8");
+    const content = await readFile2(artifactPath, "utf-8");
     return { artifact: JSON.parse(content) };
   } catch (error2) {
     const errorMessage = `Failed to read final artifact from ${outputPath}: ${error2 instanceof Error ? error2.message : String(error2)}`;
@@ -23820,7 +23540,7 @@ async function extractSandboxResult(options) {
 }
 function expandPath(path) {
   if (path.startsWith("~/") || path === "~") {
-    const home = homedir32();
+    const home = homedir3();
     if (!home) {
       throw new Error("Unable to determine home directory");
     }
@@ -23861,7 +23581,7 @@ async function checkRequiredFiles(workspaceDir) {
   }
   return true;
 }
-function createDefaultProfile2() {
+function createDefaultProfile() {
   return {
     userId: "default",
     topics: [],
@@ -23878,104 +23598,104 @@ async function createTestWorkspace(workspaceDir, force) {
     return;
   }
   if (workspaceExists) {
-    await rm22(workspaceDir, { recursive: true, force: true });
+    await rm2(workspaceDir, { recursive: true, force: true });
   }
-  await mkdir22(workspaceDir, { recursive: true });
-  await mkdir22(join52(workspaceDir, ".claude", "agents"), { recursive: true });
-  await mkdir22(join52(workspaceDir, ".claude", "skills"), { recursive: true });
-  await mkdir22(join52(workspaceDir, "sandbox"), { recursive: true });
+  await mkdir2(workspaceDir, { recursive: true });
+  await mkdir2(join52(workspaceDir, ".claude", "agents"), { recursive: true });
+  await mkdir2(join52(workspaceDir, ".claude", "skills"), { recursive: true });
+  await mkdir2(join52(workspaceDir, "sandbox"), { recursive: true });
   const plugins = getPluginPaths2();
   const writerWorkflowsDir = join52(plugins.writer, "workflows");
   if (await pathExists(writerWorkflowsDir)) {
-    await cp2(writerWorkflowsDir, join52(workspaceDir, "workflows"), {
+    await cp(writerWorkflowsDir, join52(workspaceDir, "workflows"), {
       recursive: true
     });
   } else {
-    await mkdir22(join52(workspaceDir, "workflows"), { recursive: true });
+    await mkdir2(join52(workspaceDir, "workflows"), { recursive: true });
   }
   const coreValidatorDir = join52(plugins.core, "skills", "workflow-validator");
   if (await pathExists(coreValidatorDir)) {
-    await cp2(
+    await cp(
       coreValidatorDir,
       join52(workspaceDir, ".claude", "skills", "workflow-validator"),
       { recursive: true }
     );
   }
-  await writeFile22(
+  await writeFile2(
     join52(workspaceDir, "CLAUDE.md"),
     "# Test Workspace\n",
     "utf-8"
   );
-  await writeFile22(
+  await writeFile2(
     join52(workspaceDir, "user-profile.json"),
-    JSON.stringify(createDefaultProfile2(), null, 2),
+    JSON.stringify(createDefaultProfile(), null, 2),
     "utf-8"
   );
 }
 async function bootstrapFromPlugins(workspaceDir, plugins) {
   const workspaceExists = await pathExists(workspaceDir);
   if (workspaceExists) {
-    await rm22(workspaceDir, { recursive: true, force: true });
+    await rm2(workspaceDir, { recursive: true, force: true });
   }
-  await mkdir22(workspaceDir, { recursive: true });
-  await mkdir22(join52(workspaceDir, ".claude"), { recursive: true });
-  await mkdir22(join52(workspaceDir, "sandbox"), { recursive: true });
+  await mkdir2(workspaceDir, { recursive: true });
+  await mkdir2(join52(workspaceDir, ".claude"), { recursive: true });
+  await mkdir2(join52(workspaceDir, "sandbox"), { recursive: true });
   const coreCommandsDir = join52(plugins.core, "commands");
   if (await pathExists(coreCommandsDir)) {
-    await cp2(coreCommandsDir, join52(workspaceDir, ".claude", "commands"), {
+    await cp(coreCommandsDir, join52(workspaceDir, ".claude", "commands"), {
       recursive: true
     });
   }
   const coreSkillsDir = join52(plugins.core, "skills");
   if (await pathExists(coreSkillsDir)) {
-    await cp2(coreSkillsDir, join52(workspaceDir, ".claude", "skills"), {
+    await cp(coreSkillsDir, join52(workspaceDir, ".claude", "skills"), {
       recursive: true
     });
   }
   const coreHooksDir = join52(plugins.core, "hooks");
   if (await pathExists(coreHooksDir)) {
-    await cp2(coreHooksDir, join52(workspaceDir, ".claude", "hooks"), {
+    await cp(coreHooksDir, join52(workspaceDir, ".claude", "hooks"), {
       recursive: true
     });
   }
   const coreAgentsDir = join52(plugins.core, "agents");
   if (await pathExists(coreAgentsDir)) {
-    await mkdir22(join52(workspaceDir, ".claude", "agents"), { recursive: true });
-    await cp2(coreAgentsDir, join52(workspaceDir, ".claude", "agents"), {
+    await mkdir2(join52(workspaceDir, ".claude", "agents"), { recursive: true });
+    await cp(coreAgentsDir, join52(workspaceDir, ".claude", "agents"), {
       recursive: true
     });
   }
   const coreScriptsDir = join52(plugins.core, "scripts");
   if (await pathExists(coreScriptsDir)) {
-    await cp2(coreScriptsDir, join52(workspaceDir, "scripts"), {
+    await cp(coreScriptsDir, join52(workspaceDir, "scripts"), {
       recursive: true
     });
   }
   const coreClaudeMd = join52(plugins.core, "CLAUDE.md");
   if (await pathExists(coreClaudeMd)) {
-    await cp2(coreClaudeMd, join52(workspaceDir, "CLAUDE.md"));
+    await cp(coreClaudeMd, join52(workspaceDir, "CLAUDE.md"));
   }
   const writerAgentsDir = join52(plugins.writer, "agents");
   if (await pathExists(writerAgentsDir)) {
-    await cp2(writerAgentsDir, join52(workspaceDir, ".claude", "agents"), {
+    await cp(writerAgentsDir, join52(workspaceDir, ".claude", "agents"), {
       recursive: true
     });
   }
   const writerSkillsDir = join52(plugins.writer, "skills");
   if (await pathExists(writerSkillsDir)) {
-    await cp2(writerSkillsDir, join52(workspaceDir, ".claude", "skills"), {
+    await cp(writerSkillsDir, join52(workspaceDir, ".claude", "skills"), {
       recursive: true
     });
   }
   const writerWorkflowsDir = join52(plugins.writer, "workflows");
   if (await pathExists(writerWorkflowsDir)) {
-    await cp2(writerWorkflowsDir, join52(workspaceDir, "workflows"), {
+    await cp(writerWorkflowsDir, join52(workspaceDir, "workflows"), {
       recursive: true
     });
   }
-  await writeFile22(
+  await writeFile2(
     join52(workspaceDir, "user-profile.json"),
-    JSON.stringify(createDefaultProfile2(), null, 2),
+    JSON.stringify(createDefaultProfile(), null, 2),
     "utf-8"
   );
 }
@@ -24018,7 +23738,7 @@ async function readUserProfile(workspaceDir) {
 }
 async function writeUserProfile(workspaceDir, profile) {
   const profilePath = join52(workspaceDir, "user-profile.json");
-  await writeFile22(profilePath, JSON.stringify(profile, null, 2), "utf-8");
+  await writeFile2(profilePath, JSON.stringify(profile, null, 2), "utf-8");
 }
 var workspaceCache = /* @__PURE__ */ new Map();
 async function getOrInitWorkspace(baseDir, useFilesystemExtensions) {
@@ -24089,8 +23809,13 @@ function* processEvent(event, progressTracker, context) {
     return buildFinalResult(event, context.sessionId);
   }
 }
-var loopliaSystemPrompt = `
-# Looplia Workflow Engine (v0.7.1)
+function getDefaultWorkspace() {
+  return process.env.LOOPLIA_HOME ?? `${homedir4()}/.looplia`;
+}
+function getLoopliaSystemPrompt(workspace) {
+  const ws = workspace ?? getDefaultWorkspace();
+  return `
+# Looplia Workflow Engine (v0.8.0)
 
 You are a looplia workflow engine. Execute workflows by delegating to skills.
 
@@ -24153,7 +23878,7 @@ Save generated workflow to \`workflows/{name}.md\`.
 ## Workspace Structure
 
 \`\`\`
-~/.looplia/                  # Looplia plugin root
+${ws}/                  # Looplia plugin root
 \u251C\u2500\u2500 .claude-plugin/
 \u2502   \u2514\u2500\u2500 plugin.json          # Plugin manifest
 \u251C\u2500\u2500 commands/                # /looplia:run, /looplia:build, etc.
@@ -24175,13 +23900,13 @@ Save generated workflow to \`workflows/{name}.md\`.
 
 ## Path Resolution
 
-All relative paths resolve from \`~/.looplia\` (the SDK working directory):
+All relative paths resolve from \`${ws}\` (the SDK working directory):
 
 | Path Type | Example | Resolves To |
 |-----------|---------|-------------|
-| Workflows | \`workflows/writing-kit.md\` | \`~/.looplia/workflows/writing-kit.md\` |
-| Sandbox | \`sandbox/{id}/validation.json\` | \`~/.looplia/sandbox/{id}/validation.json\` |
-| Outputs | \`sandbox/{id}/outputs/\` | \`~/.looplia/sandbox/{id}/outputs/\` |
+| Workflows | \`workflows/writing-kit.md\` | \`${ws}/workflows/writing-kit.md\` |
+| Sandbox | \`sandbox/{id}/validation.json\` | \`${ws}/sandbox/{id}/validation.json\` |
+| Outputs | \`sandbox/{id}/outputs/\` | \`${ws}/sandbox/{id}/outputs/\` |
 
 **User files** (from \`--file\` argument): Resolve against the **User Working Directory** provided in the User Context section below.
 
@@ -24209,6 +23934,8 @@ All relative paths resolve from \`~/.looplia\` (the SDK working directory):
 
 For implementation details, see the SKILL.md files in \`skills/\`.
 `;
+}
+var loopliaSystemPrompt = getLoopliaSystemPrompt();
 var SKILL_TO_STEP = {
   "content-analyzer": "analyzing",
   "idea-generator": "generating_ideas",
@@ -24578,7 +24305,7 @@ async function* executeAgenticQueryStreaming(prompt, _jsonSchema, config2) {
         systemPrompt: {
           type: "preset",
           preset: "claude_code",
-          append: `${loopliaSystemPrompt}
+          append: `${getLoopliaSystemPrompt(loopliaHome)}
 
 ## User Context
 
@@ -24791,7 +24518,7 @@ function resolveSandboxRoot(context) {
 }
 async function findMostRecentBuildSandbox(sandboxRoot) {
   try {
-    const entries = await readdir22(sandboxRoot, { withFileTypes: true });
+    const entries = await readdir2(sandboxRoot, { withFileTypes: true });
     const dirs = entries.filter(
       (e) => e.isDirectory() && e.name.startsWith("build-")
     );
@@ -24966,7 +24693,7 @@ var LOCK_TIMEOUT_MS = 3e4;
 var LOCK_RETRY_DELAY_MS2 = 200;
 async function findMostRecentSandbox2(sandboxRoot) {
   try {
-    const entries = await readdir32(sandboxRoot, { withFileTypes: true });
+    const entries = await readdir3(sandboxRoot, { withFileTypes: true });
     const dirs = entries.filter(
       (e) => e.isDirectory() && !e.name.startsWith(".")
     );
@@ -25401,7 +25128,7 @@ async function* executeInteractiveQueryStreaming(prompt, _jsonSchema, config2, q
         systemPrompt: {
           type: "preset",
           preset: "claude_code",
-          append: `${loopliaSystemPrompt}
+          append: `${getLoopliaSystemPrompt(loopliaHome)}
 
 ## User Context
 
@@ -25681,12 +25408,6 @@ var WRITING_KIT_OUTPUT_SCHEMA = {
 };
 
 export {
-  CORE_SKILLS,
-  isCoreSkill,
-  getLoopliaPluginPath,
-  copyPlugins,
-  downloadRemotePlugins,
-  isLoopliaInitialized,
   parseWorkflow,
   generateValidationManifest,
   getFinalStep,