@looplia/looplia-cli 0.7.2 → 0.7.4

package/dist/{chunk-OIE7CSW6.js → chunk-PXCY2LDE.js}

@@ -7,7 +7,7 @@ import {
   init_esm_shims
 } from "./chunk-Y55L47HC.js";
 
-// ../../packages/provider/dist/chunk-Q57VKNQX.js
+// ../../packages/provider/dist/chunk-DRG2TRPF.js
 init_esm_shims();
 import { createHash } from "crypto";
 import {
@@ -175,7 +175,7 @@ async function copyPlugins(targetDir, sourcePath) {
   );
   const { initializeRegistry, compileRegistry } = await import("./compiler-4B63UTUP-VE77VSJ2.js");
   await initializeRegistry();
-  const { syncRegistrySources } = await import("./sync-MFM46YAB-SSBMNJ7D.js");
+  const { syncRegistrySources } = await import("./sync-E5PGFGNI-IGGJR7IL.js");
   const syncResults = await syncRegistrySources({ showProgress: true });
   for (const result of syncResults) {
     if (result.status === "failed") {
@@ -293,7 +293,7 @@ async function getPluginPaths() {
   return await getProdPluginPaths();
 }
 
-// ../../packages/provider/dist/chunk-OG5PVVUV.js
+// ../../packages/provider/dist/chunk-KZZIM7FY.js
 init_esm_shims();
 import { execSync } from "child_process";
 import { existsSync as existsSync3 } from "fs";
@@ -5592,6 +5592,9 @@ var zodToJsonSchema = (schema, options) => {
   return combined;
 };
 
+// ../../packages/provider/dist/chunk-KZZIM7FY.js
+import { join as join6 } from "path";
+
 // ../../node_modules/@anthropic-ai/claude-agent-sdk/sdk.mjs
 init_esm_shims();
 import { join as join5 } from "path";
@@ -22127,12 +22130,25 @@ function query({
   return queryInstance;
 }
 
-// ../../packages/provider/dist/chunk-OG5PVVUV.js
+// ../../packages/provider/dist/chunk-KZZIM7FY.js
 import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync3, writeFileSync } from "fs";
 import { join as join33 } from "path";
-import { cp as cp2, mkdir as mkdir22, readFile as readFile22, rm as rm22, writeFile as writeFile22 } from "fs/promises";
+import { access, readdir as readdir3, readFile as readFile22, 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 { isAbsolute, join as join42, normalize, resolve } from "path";
+import { isAbsolute, join as join52, normalize, resolve } from "path";
+import {
+  open as open2,
+  readdir as readdir22,
+  readFile as readFile4,
+  rename as rename2,
+  stat as stat2,
+  unlink,
+  writeFile as writeFile3
+} from "fs/promises";
+import { join as join7 } from "path";
+import { join as join8 } from "path";
 var LINE_SPLIT_REGEX = /\r?\n/;
 function findSdkBundledCliPath() {
   try {
@@ -22226,11 +22242,42 @@ var PRESETS = {
   ANTHROPIC_CLAUDE_SONNET: {
     name: "Anthropic Claude Sonnet",
     apiProvider: "anthropic",
-    mainModel: "claude-sonnet-4-5-20250514",
-    executorModel: "claude-sonnet-4-5-20250514",
-    haikuModel: "claude-sonnet-4-5-20250514",
-    sonnetModel: "claude-sonnet-4-5-20250514",
-    opusModel: "claude-sonnet-4-5-20250514"
+    mainModel: "claude-sonnet-4-5-20250929",
+    executorModel: "claude-sonnet-4-5-20250929",
+    haikuModel: "claude-sonnet-4-5-20250929",
+    sonnetModel: "claude-sonnet-4-5-20250929",
+    opusModel: "claude-sonnet-4-5-20250929"
+  },
+  // Claude Code Subscription (macOS Keychain)
+  CLAUDE_CODE_SUBSCRIPTION_HAIKU: {
+    name: "Claude Code Subscription (Haiku)",
+    apiProvider: "anthropic",
+    authTokenSource: "subscription",
+    mainModel: "claude-haiku-4-5-20251001",
+    executorModel: "claude-haiku-4-5-20251001",
+    haikuModel: "claude-haiku-4-5-20251001",
+    sonnetModel: "claude-haiku-4-5-20251001",
+    opusModel: "claude-haiku-4-5-20251001"
+  },
+  CLAUDE_CODE_SUBSCRIPTION_SONNET: {
+    name: "Claude Code Subscription (Sonnet)",
+    apiProvider: "anthropic",
+    authTokenSource: "subscription",
+    mainModel: "claude-sonnet-4-5-20250929",
+    executorModel: "claude-sonnet-4-5-20250929",
+    haikuModel: "claude-sonnet-4-5-20250929",
+    sonnetModel: "claude-sonnet-4-5-20250929",
+    opusModel: "claude-sonnet-4-5-20250929"
+  },
+  CLAUDE_CODE_SUBSCRIPTION_OPUS: {
+    name: "Claude Code Subscription (Opus)",
+    apiProvider: "anthropic",
+    authTokenSource: "subscription",
+    mainModel: "claude-opus-4-5-20251101",
+    executorModel: "claude-opus-4-5-20251101",
+    haikuModel: "claude-opus-4-5-20251101",
+    sonnetModel: "claude-opus-4-5-20251101",
+    opusModel: "claude-opus-4-5-20251101"
   },
   // ZenMux Presets
   ZENMUX_ANTHROPIC_HAIKU45: {
@@ -22253,6 +22300,16 @@ var PRESETS = {
     sonnetModel: "z-ai/glm-4.7",
     opusModel: "z-ai/glm-4.7"
   },
+  ZENMUX_ZAI_GLM47FLASHX: {
+    name: "ZenMux GLM-4.7-FlashX",
+    apiProvider: "zenmux",
+    baseUrl: "https://zenmux.ai/api/anthropic",
+    mainModel: "z-ai/glm-4.7-flashx",
+    executorModel: "z-ai/glm-4.7-flashx",
+    haikuModel: "z-ai/glm-4.7-flashx",
+    sonnetModel: "z-ai/glm-4.7-flashx",
+    opusModel: "z-ai/glm-4.7-flashx"
+  },
   ZENMUX_MINIMAX_M21: {
     name: "ZenMux MiniMax-M2.1",
     apiProvider: "zenmux",
@@ -22372,6 +22429,48 @@ var PRESETS = {
     haikuModel: "openai/gpt-5.1-codex-mini",
     sonnetModel: "openai/gpt-5.1-codex-mini",
     opusModel: "openai/gpt-5.1-codex-mini"
+  },
+  // OpenRouter Presets
+  OPENROUTER_PRESET: {
+    name: "OpenRouter (User-Configured Preset)",
+    apiProvider: "openrouter",
+    baseUrl: "https://openrouter.ai/api",
+    mainModel: "@preset/looplia-default",
+    executorModel: "@preset/looplia-default",
+    haikuModel: "@preset/looplia-default",
+    sonnetModel: "@preset/looplia-default",
+    opusModel: "@preset/looplia-default"
+  },
+  OPENROUTER_ZAI_GLM47FLASH: {
+    name: "OpenRouter GLM-4.7-Flash",
+    apiProvider: "openrouter",
+    baseUrl: "https://openrouter.ai/api",
+    mainModel: "z-ai/glm-4.7-flash",
+    executorModel: "z-ai/glm-4.7-flash",
+    haikuModel: "z-ai/glm-4.7-flash",
+    sonnetModel: "z-ai/glm-4.7-flash",
+    opusModel: "z-ai/glm-4.7-flash"
+  },
+  // Ollama Cloud Presets
+  OLLAMA_GLM47_CLOUD: {
+    name: "Ollama GLM-4.7 Cloud",
+    apiProvider: "ollama",
+    baseUrl: "http://localhost:11434",
+    mainModel: "glm-4.7:cloud",
+    executorModel: "glm-4.7:cloud",
+    haikuModel: "glm-4.7:cloud",
+    sonnetModel: "glm-4.7:cloud",
+    opusModel: "glm-4.7:cloud"
+  },
+  OLLAMA_MINIMAX_M21_CLOUD: {
+    name: "Ollama MiniMax-M2.1 Cloud",
+    apiProvider: "ollama",
+    baseUrl: "http://localhost:11434",
+    mainModel: "minimax-m2.1:cloud",
+    executorModel: "minimax-m2.1:cloud",
+    haikuModel: "minimax-m2.1:cloud",
+    sonnetModel: "minimax-m2.1:cloud",
+    opusModel: "minimax-m2.1:cloud"
   }
 };
 var CONFIG_FILE = "looplia.setting.json";
@@ -22423,19 +22522,45 @@ function injectModelTierEnv(mainModel, executorModel) {
   setEnvIfNotSet("LOOPLIA_AGENT_MODEL_MAIN", mainModel);
   setEnvIfNotSet("LOOPLIA_AGENT_MODEL_EXECUTOR", executorModel);
 }
-function injectLoopliaSettingsEnv(settings) {
-  if (settings.apiProvider.type !== "anthropic") {
-    if (settings.apiProvider.baseUrl && !process.env.ANTHROPIC_BASE_URL) {
-      process.env.ANTHROPIC_BASE_URL = settings.apiProvider.baseUrl;
-    }
-    if (settings.apiProvider.authToken) {
-      process.env.ANTHROPIC_API_KEY = settings.apiProvider.authToken;
+function injectSubscriptionAuth() {
+  if (!process.env.CLAUDE_CODE_OAUTH_TOKEN) {
+    console.warn(
+      "Warning: CLAUDE_CODE_OAUTH_TOKEN not set. Set this environment variable to use Claude Code subscription auth."
+    );
+  }
+  process.env.ANTHROPIC_API_KEY = void 0;
+}
+function injectNonAnthropicProviderEnv(apiProvider) {
+  if (apiProvider.baseUrl && !process.env.ANTHROPIC_BASE_URL) {
+    process.env.ANTHROPIC_BASE_URL = apiProvider.baseUrl;
+  }
+  const isOpenRouterEndpoint = apiProvider.type === "openrouter" || apiProvider.baseUrl?.includes("openrouter.ai");
+  const isZenmuxEndpoint = apiProvider.type === "zenmux" || apiProvider.baseUrl?.includes("zenmux.ai");
+  const isOllamaEndpoint = apiProvider.type === "ollama" || apiProvider.baseUrl?.includes("localhost:11434");
+  if (apiProvider.authToken) {
+    if (isOpenRouterEndpoint) {
+      process.env.ANTHROPIC_AUTH_TOKEN = apiProvider.authToken;
+      process.env.ANTHROPIC_API_KEY = void 0;
     } else {
-      const isZenmuxEndpoint = settings.apiProvider.type === "zenmux" || settings.apiProvider.baseUrl?.includes("zenmux.ai");
-      if (isZenmuxEndpoint && process.env.ZENMUX_API_KEY) {
-        process.env.ANTHROPIC_API_KEY = process.env.ZENMUX_API_KEY;
-      }
+      process.env.ANTHROPIC_API_KEY = apiProvider.authToken;
     }
+    return;
+  }
+  if (isZenmuxEndpoint && process.env.ZENMUX_API_KEY) {
+    process.env.ANTHROPIC_API_KEY = process.env.ZENMUX_API_KEY;
+  } else if (isOpenRouterEndpoint && process.env.OPENROUTER_API_KEY) {
+    process.env.ANTHROPIC_AUTH_TOKEN = process.env.OPENROUTER_API_KEY;
+    process.env.ANTHROPIC_API_KEY = void 0;
+  } else if (isOllamaEndpoint) {
+    process.env.ANTHROPIC_API_KEY = process.env.OLLAMA_API_KEY || "ollama";
+  }
+}
+function injectLoopliaSettingsEnv(settings) {
+  if (settings.apiProvider.authTokenSource === "subscription") {
+    injectSubscriptionAuth();
+  }
+  if (settings.apiProvider.type !== "anthropic") {
+    injectNonAnthropicProviderEnv(settings.apiProvider);
   }
   injectModelTierEnv(settings.agents.main, settings.agents.executor);
 }
@@ -22456,6 +22581,7 @@ function getSettingsDisplayInfo(settings) {
     preset: settings.preset,
     provider,
     authToken: settings.apiProvider.authToken,
+    authTokenSource: settings.apiProvider.authTokenSource,
     agents: {
       main: settings.agents.main,
       executor: settings.agents.executor
@@ -22479,7 +22605,8 @@ function applyPreset(presetName, existingSettings) {
     apiProvider: {
       type: preset.apiProvider,
       baseUrl: preset.baseUrl,
-      authToken: existingSettings?.apiProvider.authToken
+      authToken: existingSettings?.apiProvider.authToken,
+      authTokenSource: preset.authTokenSource
     },
     agents: {
       main: preset.mainModel,
@@ -22498,17 +22625,19 @@ async function initializeCommandEnvironment(options = {}) {
   return { settings };
 }
 function validateApiKeyPresence() {
-  if (!(process.env.ANTHROPIC_API_KEY || process.env.CLAUDE_CODE_OAUTH_TOKEN)) {
+  if (!(process.env.ANTHROPIC_API_KEY || process.env.ANTHROPIC_AUTH_TOKEN || process.env.CLAUDE_CODE_OAUTH_TOKEN)) {
     console.error("Error: API key required");
     console.error("");
     console.error("Options:");
     console.error("  1. Set ANTHROPIC_API_KEY environment variable");
     console.error("  2. Set ZENMUX_API_KEY with a ZenMux preset");
-    console.error("  3. Configure via: looplia config provider preset <name>");
-    console.error("  4. Use --mock flag for testing without API");
+    console.error("  3. Set OPENROUTER_API_KEY with an OpenRouter preset");
+    console.error("  4. Configure via: looplia config provider preset <name>");
+    console.error("  5. Use --mock flag for testing without API");
     console.error("");
     console.error("Get your API key from: https://console.anthropic.com");
     console.error("Or use ZenMux at: https://zenmux.ai");
+    console.error("Or use OpenRouter at: https://openrouter.ai");
     process.exit(1);
   }
 }
@@ -22685,13 +22814,186 @@ function extractSandboxIdFromPrompt(prompt) {
   return decodedId;
 }
 var extractContentIdFromPrompt = extractSandboxIdFromPrompt;
+var LOCK_MAX_RETRIES = 5;
+var LOCK_RETRY_DELAY_MS = 200;
+function isValidationManifest(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const obj = value;
+  return typeof obj.workflow === "string" && typeof obj.steps === "object" && obj.steps !== null;
+}
+async function sleep(ms) {
+  await new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function lockExists(lockPath) {
+  try {
+    await access(lockPath);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function validationError(field, message) {
+  return {
+    success: false,
+    error: { type: "validation_error", field, message }
+  };
+}
+async function findMostRecentSandbox(sandboxRoot) {
+  try {
+    const entries = await readdir3(sandboxRoot, { withFileTypes: true });
+    const dirs = entries.filter(
+      (e) => e.isDirectory() && !e.name.startsWith(".")
+    );
+    if (dirs.length === 0) {
+      return;
+    }
+    const dirStats = await Promise.all(
+      dirs.map(async (dir) => {
+        const dirPath = join42(sandboxRoot, dir.name);
+        const dirStat = await stat(dirPath);
+        return { path: dirPath, mtime: dirStat.mtime.getTime() };
+      })
+    );
+    dirStats.sort((a, b) => b.mtime - a.mtime);
+    return dirStats[0]?.path;
+  } catch {
+    return;
+  }
+}
+function findFinalStep(steps) {
+  const stepEntries = Object.entries(steps);
+  if (stepEntries.length === 0) {
+    return;
+  }
+  const lastEntry = stepEntries.at(-1);
+  if (!lastEntry) {
+    return;
+  }
+  return { id: lastEntry[0], output: lastEntry[1].output };
+}
+function resolveFinalStep(steps, finalStepId) {
+  if (finalStepId) {
+    const step = steps[finalStepId];
+    if (step?.output) {
+      return { id: finalStepId, output: step.output };
+    }
+  }
+  return findFinalStep(steps);
+}
+function areAllStepsValidated(steps) {
+  const pendingSteps = [];
+  for (const [stepId, stepState] of Object.entries(steps)) {
+    if (!stepState.validated) {
+      pendingSteps.push(stepId);
+    }
+  }
+  return {
+    allValidated: pendingSteps.length === 0,
+    pendingSteps
+  };
+}
+function resolveSandboxDir(sandboxRoot, sandboxId) {
+  if (sandboxId) {
+    return join42(sandboxRoot, sandboxId);
+  }
+  return findMostRecentSandbox(sandboxRoot);
+}
+async function readValidationManifest(sandboxDir) {
+  const validationPath = join42(sandboxDir, "validation.json");
+  const lockPath = `${validationPath}.lock`;
+  for (let attempt = 0; attempt < LOCK_MAX_RETRIES; attempt++) {
+    if (await lockExists(lockPath)) {
+      await sleep(LOCK_RETRY_DELAY_MS);
+      continue;
+    }
+    try {
+      const content = await readFile22(validationPath, "utf-8");
+      const parsed = JSON.parse(content);
+      if (!isValidationManifest(parsed)) {
+        return { error: "Invalid validation manifest structure" };
+      }
+      return { manifest: parsed };
+    } catch (error2) {
+      const message = error2 instanceof Error ? error2.message : String(error2);
+      return { error: `Failed to read validation.json: ${message}` };
+    }
+  }
+  return { error: "Timeout waiting for validation.json lock to release" };
+}
+async function readFinalArtifact(sandboxDir, outputPath) {
+  const artifactPath = join42(sandboxDir, outputPath);
+  try {
+    const content = await readFile22(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)}`;
+    const isParseError = error2 instanceof Error && error2.message.includes("JSON");
+    if (isParseError) {
+      return {
+        error: {
+          success: false,
+          error: {
+            type: "malformed_output",
+            expected: "valid JSON",
+            got: "invalid JSON",
+            message: errorMessage
+          }
+        }
+      };
+    }
+    return { error: validationError("artifact", errorMessage) };
+  }
+}
+async function extractSandboxResult(options) {
+  const loopliaHome = getLoopliaPluginPath();
+  const sandboxRoot = options?.sandboxRoot ?? join42(loopliaHome, "sandbox");
+  const sandboxId = options?.sandboxId;
+  const sandboxDir = await resolveSandboxDir(sandboxRoot, sandboxId);
+  if (!sandboxDir) {
+    const message = sandboxId ? `Sandbox not found: ${sandboxId}` : "No sandbox directories found";
+    return validationError("sandbox", message);
+  }
+  const { manifest, error: readError } = await readValidationManifest(sandboxDir);
+  if (!manifest) {
+    return validationError("validation.json", readError ?? "Unknown error");
+  }
+  const { allValidated, pendingSteps } = areAllStepsValidated(manifest.steps);
+  if (!allValidated) {
+    return validationError(
+      "steps",
+      `Workflow incomplete. Pending steps: ${pendingSteps.join(", ")}`
+    );
+  }
+  const finalStep = resolveFinalStep(manifest.steps, manifest.finalStepId);
+  if (!finalStep) {
+    return validationError("steps", "No steps found in validation manifest");
+  }
+  const { artifact, error: artifactError } = await readFinalArtifact(
+    sandboxDir,
+    finalStep.output
+  );
+  if (artifactError) {
+    return artifactError;
+  }
+  return {
+    success: true,
+    data: {
+      status: "success",
+      sandboxId: manifest.sandboxId ?? sandboxDir.split("/").pop(),
+      workflowId: manifest.workflow,
+      artifact
+    }
+  };
+}
 function expandPath(path) {
   if (path.startsWith("~/") || path === "~") {
     const home = homedir32();
     if (!home) {
       throw new Error("Unable to determine home directory");
     }
-    const expanded = path === "~" ? home : join42(home, path.slice(2));
+    const expanded = path === "~" ? home : join52(home, path.slice(2));
     return normalize(expanded);
   }
   if (isAbsolute(path)) {
@@ -22700,26 +23002,26 @@ function expandPath(path) {
   return normalize(resolve(path));
 }
 function getPluginPath() {
-  return join42(process.cwd(), "plugins", "looplia-writer");
+  return join52(process.cwd(), "plugins", "looplia-writer");
 }
 function getPluginPaths2() {
-  const base = join42(process.cwd(), "plugins");
+  const base = join52(process.cwd(), "plugins");
   return {
-    core: join42(base, "looplia-core"),
-    writer: join42(base, "looplia-writer")
+    core: join52(base, "looplia-core"),
+    writer: join52(base, "looplia-writer")
   };
 }
 async function checkRequiredFiles(workspaceDir) {
   const requiredPaths = [
     // Core structure
-    join42(workspaceDir, "CLAUDE.md"),
-    join42(workspaceDir, ".claude", "agents"),
-    join42(workspaceDir, ".claude", "skills"),
-    join42(workspaceDir, "workflows"),
+    join52(workspaceDir, "CLAUDE.md"),
+    join52(workspaceDir, ".claude", "agents"),
+    join52(workspaceDir, ".claude", "skills"),
+    join52(workspaceDir, "workflows"),
     // From looplia-core plugin
-    join42(workspaceDir, ".claude", "commands"),
-    join42(workspaceDir, ".claude", "skills", "workflow-executor"),
-    join42(workspaceDir, ".claude", "skills", "workflow-validator")
+    join52(workspaceDir, ".claude", "commands"),
+    join52(workspaceDir, ".claude", "skills", "workflow-executor"),
+    join52(workspaceDir, ".claude", "skills", "workflow-validator")
   ];
   for (const path of requiredPaths) {
     if (!await pathExists(path)) {
@@ -22748,33 +23050,33 @@ async function createTestWorkspace(workspaceDir, force) {
     await rm22(workspaceDir, { recursive: true, force: true });
   }
   await mkdir22(workspaceDir, { recursive: true });
-  await mkdir22(join42(workspaceDir, ".claude", "agents"), { recursive: true });
-  await mkdir22(join42(workspaceDir, ".claude", "skills"), { recursive: true });
-  await mkdir22(join42(workspaceDir, "sandbox"), { 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 });
   const plugins = getPluginPaths2();
-  const writerWorkflowsDir = join42(plugins.writer, "workflows");
+  const writerWorkflowsDir = join52(plugins.writer, "workflows");
   if (await pathExists(writerWorkflowsDir)) {
-    await cp2(writerWorkflowsDir, join42(workspaceDir, "workflows"), {
+    await cp2(writerWorkflowsDir, join52(workspaceDir, "workflows"), {
       recursive: true
     });
   } else {
-    await mkdir22(join42(workspaceDir, "workflows"), { recursive: true });
+    await mkdir22(join52(workspaceDir, "workflows"), { recursive: true });
   }
-  const coreValidatorDir = join42(plugins.core, "skills", "workflow-validator");
+  const coreValidatorDir = join52(plugins.core, "skills", "workflow-validator");
   if (await pathExists(coreValidatorDir)) {
     await cp2(
       coreValidatorDir,
-      join42(workspaceDir, ".claude", "skills", "workflow-validator"),
+      join52(workspaceDir, ".claude", "skills", "workflow-validator"),
       { recursive: true }
     );
   }
   await writeFile22(
-    join42(workspaceDir, "CLAUDE.md"),
+    join52(workspaceDir, "CLAUDE.md"),
     "# Test Workspace\n",
     "utf-8"
   );
   await writeFile22(
-    join42(workspaceDir, "user-profile.json"),
+    join52(workspaceDir, "user-profile.json"),
     JSON.stringify(createDefaultProfile2(), null, 2),
     "utf-8"
   );
@@ -22785,63 +23087,63 @@ async function bootstrapFromPlugins(workspaceDir, plugins) {
     await rm22(workspaceDir, { recursive: true, force: true });
   }
   await mkdir22(workspaceDir, { recursive: true });
-  await mkdir22(join42(workspaceDir, ".claude"), { recursive: true });
-  await mkdir22(join42(workspaceDir, "sandbox"), { recursive: true });
-  const coreCommandsDir = join42(plugins.core, "commands");
+  await mkdir22(join52(workspaceDir, ".claude"), { recursive: true });
+  await mkdir22(join52(workspaceDir, "sandbox"), { recursive: true });
+  const coreCommandsDir = join52(plugins.core, "commands");
   if (await pathExists(coreCommandsDir)) {
-    await cp2(coreCommandsDir, join42(workspaceDir, ".claude", "commands"), {
+    await cp2(coreCommandsDir, join52(workspaceDir, ".claude", "commands"), {
       recursive: true
     });
   }
-  const coreSkillsDir = join42(plugins.core, "skills");
+  const coreSkillsDir = join52(plugins.core, "skills");
   if (await pathExists(coreSkillsDir)) {
-    await cp2(coreSkillsDir, join42(workspaceDir, ".claude", "skills"), {
+    await cp2(coreSkillsDir, join52(workspaceDir, ".claude", "skills"), {
       recursive: true
     });
   }
-  const coreHooksDir = join42(plugins.core, "hooks");
+  const coreHooksDir = join52(plugins.core, "hooks");
   if (await pathExists(coreHooksDir)) {
-    await cp2(coreHooksDir, join42(workspaceDir, ".claude", "hooks"), {
+    await cp2(coreHooksDir, join52(workspaceDir, ".claude", "hooks"), {
       recursive: true
     });
   }
-  const coreAgentsDir = join42(plugins.core, "agents");
+  const coreAgentsDir = join52(plugins.core, "agents");
   if (await pathExists(coreAgentsDir)) {
-    await mkdir22(join42(workspaceDir, ".claude", "agents"), { recursive: true });
-    await cp2(coreAgentsDir, join42(workspaceDir, ".claude", "agents"), {
+    await mkdir22(join52(workspaceDir, ".claude", "agents"), { recursive: true });
+    await cp2(coreAgentsDir, join52(workspaceDir, ".claude", "agents"), {
       recursive: true
     });
   }
-  const coreScriptsDir = join42(plugins.core, "scripts");
+  const coreScriptsDir = join52(plugins.core, "scripts");
   if (await pathExists(coreScriptsDir)) {
-    await cp2(coreScriptsDir, join42(workspaceDir, "scripts"), {
+    await cp2(coreScriptsDir, join52(workspaceDir, "scripts"), {
       recursive: true
     });
   }
-  const coreClaudeMd = join42(plugins.core, "CLAUDE.md");
+  const coreClaudeMd = join52(plugins.core, "CLAUDE.md");
   if (await pathExists(coreClaudeMd)) {
-    await cp2(coreClaudeMd, join42(workspaceDir, "CLAUDE.md"));
+    await cp2(coreClaudeMd, join52(workspaceDir, "CLAUDE.md"));
   }
-  const writerAgentsDir = join42(plugins.writer, "agents");
+  const writerAgentsDir = join52(plugins.writer, "agents");
   if (await pathExists(writerAgentsDir)) {
-    await cp2(writerAgentsDir, join42(workspaceDir, ".claude", "agents"), {
+    await cp2(writerAgentsDir, join52(workspaceDir, ".claude", "agents"), {
       recursive: true
     });
   }
-  const writerSkillsDir = join42(plugins.writer, "skills");
+  const writerSkillsDir = join52(plugins.writer, "skills");
   if (await pathExists(writerSkillsDir)) {
-    await cp2(writerSkillsDir, join42(workspaceDir, ".claude", "skills"), {
+    await cp2(writerSkillsDir, join52(workspaceDir, ".claude", "skills"), {
       recursive: true
     });
   }
-  const writerWorkflowsDir = join42(plugins.writer, "workflows");
+  const writerWorkflowsDir = join52(plugins.writer, "workflows");
   if (await pathExists(writerWorkflowsDir)) {
-    await cp2(writerWorkflowsDir, join42(workspaceDir, "workflows"), {
+    await cp2(writerWorkflowsDir, join52(workspaceDir, "workflows"), {
       recursive: true
     });
   }
   await writeFile22(
-    join42(workspaceDir, "user-profile.json"),
+    join52(workspaceDir, "user-profile.json"),
     JSON.stringify(createDefaultProfile2(), null, 2),
     "utf-8"
   );
@@ -22879,12 +23181,12 @@ function getWorkspacePath(baseDir) {
   return expandPath(baseDir ?? "~/.looplia");
 }
 async function readUserProfile(workspaceDir) {
-  const profilePath = join42(workspaceDir, "user-profile.json");
-  const content = await readFile22(profilePath, "utf-8");
+  const profilePath = join52(workspaceDir, "user-profile.json");
+  const content = await readFile3(profilePath, "utf-8");
   return JSON.parse(content);
 }
 async function writeUserProfile(workspaceDir, profile) {
-  const profilePath = join42(workspaceDir, "user-profile.json");
+  const profilePath = join52(workspaceDir, "user-profile.json");
   await writeFile22(profilePath, JSON.stringify(profile, null, 2), "utf-8");
 }
 var workspaceCache = /* @__PURE__ */ new Map();
@@ -22902,7 +23204,7 @@ async function getOrInitWorkspace(baseDir, useFilesystemExtensions) {
   return workspace;
 }
 function getApiKey(config2) {
-  return config2?.apiKey ?? process.env.ANTHROPIC_API_KEY ?? process.env.CLAUDE_CODE_OAUTH_TOKEN;
+  return config2?.apiKey ?? process.env.ANTHROPIC_API_KEY ?? process.env.ANTHROPIC_AUTH_TOKEN ?? process.env.CLAUDE_CODE_OAUTH_TOKEN;
 }
 async function initializeAndValidateApiKey(config2) {
   const settings = await readLoopliaSettings();
@@ -22912,7 +23214,7 @@ async function initializeAndValidateApiKey(config2) {
   const apiKey = getApiKey(config2);
   if (!apiKey) {
     throw new Error(
-      "API key is required. Set ANTHROPIC_API_KEY or CLAUDE_CODE_OAUTH_TOKEN environment variable"
+      "API key is required. Set ANTHROPIC_API_KEY, ANTHROPIC_AUTH_TOKEN, or CLAUDE_CODE_OAUTH_TOKEN environment variable"
     );
   }
   return apiKey;
@@ -23392,7 +23694,7 @@ function truncate(str, maxLen) {
   }
   return `${str.slice(0, maxLen - 3)}...`;
 }
-async function* executeAgenticQueryStreaming(prompt, jsonSchema, config2) {
+async function* executeAgenticQueryStreaming(prompt, _jsonSchema, config2) {
   const resolvedConfig = resolveConfig(config2);
   await initializeAndValidateApiKey(config2);
   const mainModel = getMainModel();
@@ -23464,8 +23766,12 @@ When processing --file arguments or user file paths, resolve them against the Us
           "WebSearch",
           "WebFetch"
         ],
-        outputFormat: { type: "json_schema", schema: jsonSchema }
+        // v0.7.2: Removed outputFormat to support non-Anthropic models
+        // Final results are now extracted from sandbox output files via extractSandboxResult()
         // v0.6.9: No custom agents - using built-in general-purpose for workflow steps
+        // v0.7.4: Pass runHooks from config if provided (workflow protection)
+        // Only the run command passes hooks - other SDK usage doesn't need them
+        ...config2?.runHooks && { hooks: config2.runHooks }
       }
     });
     let finalResult;
@@ -23489,6 +23795,12 @@ When processing --file arguments or user file paths, resolve them against the Us
     }
     logger.close();
     yield progressTracker.onComplete();
+    if (!finalResult) {
+      finalResult = await extractSandboxResult({
+        sandboxId: process.env.LOOPLIA_SANDBOX_ID,
+        sandboxRoot: process.env.LOOPLIA_SANDBOX_ROOT ?? join6(workspace, "sandbox")
+      });
+    }
     return finalResult ?? {
       success: false,
       error: { type: "unknown", message: "No result received" }
@@ -23633,6 +23945,337 @@ function createClaudeAgentExecutor(config2) {
     }
   };
 }
+var JSON_EXTENSION_REGEX = /\.json$/;
+var LOCK_TIMEOUT_MS = 3e4;
+var LOCK_RETRY_DELAY_MS2 = 200;
+async function findMostRecentSandbox2(sandboxRoot) {
+  try {
+    const entries = await readdir22(sandboxRoot, { withFileTypes: true });
+    const dirs = entries.filter(
+      (e) => e.isDirectory() && !e.name.startsWith(".")
+    );
+    if (dirs.length === 0) {
+      return;
+    }
+    const dirStats = await Promise.all(
+      dirs.map(async (dir) => {
+        const dirPath = join7(sandboxRoot, dir.name);
+        const dirStat = await stat2(dirPath);
+        return { path: dirPath, mtime: dirStat.mtime.getTime() };
+      })
+    );
+    dirStats.sort((a, b) => b.mtime - a.mtime);
+    return dirStats[0]?.path;
+  } catch {
+    return;
+  }
+}
+async function readValidationManifest2(sandboxDir) {
+  const validationPath = join7(sandboxDir, "validation.json");
+  try {
+    const content = await readFile4(validationPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return;
+  }
+}
+function resolveSandboxRoot(context) {
+  return context?.sandboxRoot ?? join7(getLoopliaPluginPath(), "sandbox");
+}
+async function resolveSandboxDir2(context) {
+  const sandboxRoot = resolveSandboxRoot(context);
+  if (context?.sandboxId) {
+    return join7(sandboxRoot, context.sandboxId);
+  }
+  return await findMostRecentSandbox2(sandboxRoot);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function getSandboxArtifactInfo(filePath) {
+  if (!filePath) {
+    return;
+  }
+  if (!(filePath.includes("/sandbox/") && filePath.includes("/outputs/"))) {
+    return;
+  }
+  const outputsIndex = filePath.lastIndexOf("/outputs/");
+  if (outputsIndex < 0) {
+    return;
+  }
+  const sandboxDir = filePath.slice(0, outputsIndex);
+  const filename = filePath.slice(outputsIndex + "/outputs/".length);
+  const artifact = filename.replace(JSON_EXTENSION_REGEX, "");
+  return { sandboxDir, artifact };
+}
+async function readArtifactData(filePath, artifact) {
+  try {
+    const content = await readFile4(filePath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    console.error(`Validation failed for ${artifact}: Invalid JSON`);
+    return;
+  }
+}
+function validateWorkflowArtifact(data, criteria) {
+  const checks = [];
+  if (criteria.required_fields) {
+    checks.push(...checkRequiredFields(data, criteria.required_fields));
+  }
+  if (criteria.min_quotes !== void 0) {
+    checks.push(checkMinQuotes(data, criteria.min_quotes));
+  }
+  if (criteria.min_key_points !== void 0) {
+    checks.push(checkMinKeyPoints(data, criteria.min_key_points));
+  }
+  if (criteria.min_outline_sections !== void 0) {
+    checks.push(checkMinOutlineSections(data, criteria.min_outline_sections));
+  }
+  if (criteria.has_hooks === true) {
+    checks.push(checkHasHooks(data));
+  }
+  const passed = checks.every((check2) => check2.passed);
+  return { passed, checks };
+}
+function checkRequiredFields(data, fields) {
+  return fields.map((field) => {
+    const exists = hasField(data, field);
+    return {
+      name: `has_${field}`,
+      passed: exists,
+      message: exists ? "OK" : `Missing required field: ${field}`
+    };
+  });
+}
+function checkMinQuotes(data, minQuotes) {
+  const quotes = getArrayLength(data, "importantQuotes");
+  const passed = quotes >= minQuotes;
+  return {
+    name: "min_quotes",
+    passed,
+    message: passed ? `Found ${quotes} quotes (min: ${minQuotes})` : `Found ${quotes} quotes, need at least ${minQuotes}`
+  };
+}
+function checkMinKeyPoints(data, minPoints) {
+  const bullets = getArrayLength(data, "bullets");
+  const keyPoints = getArrayLength(data, "keyPoints");
+  const count = Math.max(bullets, keyPoints);
+  const passed = count >= minPoints;
+  return {
+    name: "min_key_points",
+    passed,
+    message: passed ? `Found ${count} key points (min: ${minPoints})` : `Found ${count} key points, need at least ${minPoints}`
+  };
+}
+function checkMinOutlineSections(data, minSections) {
+  const sections = getArrayLength(data, "suggestedOutline");
+  const passed = sections >= minSections;
+  return {
+    name: "min_outline_sections",
+    passed,
+    message: passed ? `Found ${sections} outline sections (min: ${minSections})` : `Found ${sections} sections, need at least ${minSections}`
+  };
+}
+function checkHasHooks(data) {
+  const hooksCount = getHooksCount(data);
+  const passed = hooksCount > 0;
+  return {
+    name: "has_hooks",
+    passed,
+    message: passed ? `Found ${hooksCount} hooks` : "No hooks found in artifact"
+  };
+}
+function getHooksCount(data) {
+  const ideas = data.ideas;
+  if (ideas && Array.isArray(ideas.hooks)) {
+    return ideas.hooks.length;
+  }
+  if (Array.isArray(data.hooks)) {
+    return data.hooks.length;
+  }
+  return 0;
+}
+function hasField(data, field) {
+  const parts = field.split(".");
+  let current = data;
+  for (const part of parts) {
+    if (current === null || typeof current !== "object") {
+      return false;
+    }
+    current = current[part];
+  }
+  return current !== void 0 && current !== null;
+}
+function getArrayLength(data, field) {
+  const value = data[field];
+  return Array.isArray(value) ? value.length : 0;
+}
+function validateArtifactData(artifact, artifactData, criteria) {
+  if (criteria === void 0 || criteria === null) {
+    return true;
+  }
+  if (!isRecord(criteria)) {
+    console.error(`Validation failed for ${artifact}: Invalid criteria`);
+    return false;
+  }
+  const result = validateWorkflowArtifact(
+    artifactData,
+    criteria
+  );
+  if (!result.passed) {
+    console.error(`Semantic validation failed for ${artifact}:`);
+    console.error(JSON.stringify(result, null, 2));
+  }
+  return result.passed;
+}
+async function sleep2(ms) {
+  await new Promise((resolve2) => setTimeout(resolve2, ms));
+}
+async function acquireLock(lockPath, timeoutMs) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    try {
+      const handle = await open2(lockPath, "wx");
+      return {
+        release: async () => {
+          await handle.close();
+          try {
+            await unlink(lockPath);
+          } catch {
+          }
+        }
+      };
+    } catch (error2) {
+      if (error2 instanceof Error && "code" in error2 && error2.code === "EEXIST") {
+        await sleep2(LOCK_RETRY_DELAY_MS2);
+        continue;
+      }
+      throw error2;
+    }
+  }
+  return;
+}
+async function writeValidationManifest(validationPath, manifest) {
+  const tempPath = `${validationPath}.tmp`;
+  await writeFile3(tempPath, JSON.stringify(manifest, null, 2), "utf-8");
+  await rename2(tempPath, validationPath);
+}
+async function findMissingOutputs(sandboxDir, steps) {
+  const missing = [];
+  for (const [stepId, stepState] of Object.entries(steps)) {
+    const outputPath = stepState.output;
+    if (!outputPath) {
+      continue;
+    }
+    const fullPath = join7(sandboxDir, outputPath);
+    try {
+      await stat2(fullPath);
+    } catch {
+      missing.push(stepId);
+    }
+  }
+  return missing;
+}
+function findPendingSteps(steps) {
+  return Object.entries(steps).filter(([, stepState]) => !stepState.validated).map(([stepId]) => stepId);
+}
+function createStopGuardHook(context) {
+  return async (input) => {
+    const hookInput = input;
+    if (hookInput.stop_hook_active === true) {
+      return {};
+    }
+    const sandboxDir = await resolveSandboxDir2(context);
+    if (!sandboxDir) {
+      return {};
+    }
+    const manifest = await readValidationManifest2(sandboxDir);
+    if (!manifest) {
+      return {};
+    }
+    const missingOutputs = await findMissingOutputs(sandboxDir, manifest.steps);
+    if (missingOutputs.length > 0) {
+      const stepsList = missingOutputs.join(", ");
+      return {
+        decision: "block",
+        reason: `Your workflow is not complete. You still need to create output files for these steps: ${stepsList}. Please continue working on the workflow by using the Write tool to create the required JSON files at the paths specified in validation.json for each incomplete step. Do not stop until all workflow steps have their output files created.`
+      };
+    }
+    const pendingSteps = findPendingSteps(manifest.steps);
+    if (pendingSteps.length > 0) {
+      const stepsList = pendingSteps.join(", ");
+      return {
+        decision: "block",
+        reason: `Your workflow is not complete. The following steps need validation: ${stepsList}. The output files exist but have not been validated yet. Please re-write these output files using the Write tool to trigger validation. Do not stop until all workflow steps are validated.`
+      };
+    }
+    return {};
+  };
+}
+var stopGuardHook = createStopGuardHook();
+function createPostWriteValidateHook() {
+  return async (input) => {
+    const hookInput = input;
+    const filePath = hookInput.tool_input?.file_path;
+    const artifactInfo = getSandboxArtifactInfo(filePath);
+    if (!(artifactInfo && filePath)) {
+      return {};
+    }
+    const artifactData = await readArtifactData(
+      filePath,
+      artifactInfo.artifact
+    );
+    if (!artifactData) {
+      return {};
+    }
+    const validationPath = join7(artifactInfo.sandboxDir, "validation.json");
+    const lock = await acquireLock(`${validationPath}.lock`, LOCK_TIMEOUT_MS);
+    if (!lock) {
+      console.error("Failed to acquire lock on validation.json");
+      return {};
+    }
+    try {
+      const manifest = await readValidationManifest2(artifactInfo.sandboxDir);
+      if (!manifest) {
+        return {};
+      }
+      const stepState = manifest.steps[artifactInfo.artifact];
+      if (!stepState) {
+        return {};
+      }
+      const isValid3 = validateArtifactData(
+        artifactInfo.artifact,
+        artifactData,
+        stepState.validate
+      );
+      if (!isValid3) {
+        return {};
+      }
+      manifest.steps[artifactInfo.artifact] = {
+        ...stepState,
+        validated: true,
+        validatedAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      await writeValidationManifest(validationPath, manifest);
+      console.error(`\u2713 Validated: ${artifactInfo.artifact}.json`);
+    } finally {
+      await lock.release();
+    }
+    return {};
+  };
+}
+var postWriteValidateHook = createPostWriteValidateHook();
+function createWorkflowHooks() {
+  const context = {
+    sandboxId: process.env.LOOPLIA_SANDBOX_ID,
+    sandboxRoot: process.env.LOOPLIA_SANDBOX_ROOT
+  };
+  return {
+    Stop: [{ hooks: [createStopGuardHook(context)] }],
+    SubagentStop: [{ hooks: [createStopGuardHook(context)] }],
+    PostToolUse: [{ matcher: "Write", hooks: [createPostWriteValidateHook()] }]
+  };
+}
 var SUMMARIZE_SYSTEM_PROMPT = `You are an expert content analyst specializing in summarization and content intelligence.
 
 Your expertise includes:
@@ -23663,7 +24306,7 @@ The content-analyzer agent will:
 3. Use content-documenter skill for structured documentation
 4. Write results to sandbox/${content.id}/outputs/summary.json`;
 }
-async function* executeInteractiveQueryStreaming(prompt, jsonSchema, config2, questionCallback) {
+async function* executeInteractiveQueryStreaming(prompt, _jsonSchema, config2, questionCallback) {
   const resolvedConfig = resolveConfig(config2);
   await initializeAndValidateApiKey(config2);
   const mainModel = getMainModel();
@@ -23761,8 +24404,9 @@ When processing --file arguments or user file paths, resolve them against the Us
           "WebFetch",
           "AskUserQuestion"
           // Only in interactive mode
-        ],
-        outputFormat: { type: "json_schema", schema: jsonSchema }
+        ]
+        // v0.7.2: Removed outputFormat to support non-Anthropic models
+        // Final results are now extracted from sandbox output files via extractSandboxResult()
       }
     });
     let finalResult;
@@ -23786,6 +24430,12 @@ When processing --file arguments or user file paths, resolve them against the Us
     }
     logger.close();
     yield progressTracker.onComplete();
+    if (!finalResult) {
+      finalResult = await extractSandboxResult({
+        sandboxId: process.env.LOOPLIA_SANDBOX_ID,
+        sandboxRoot: process.env.LOOPLIA_SANDBOX_ROOT ?? join8(workspace, "sandbox")
+      });
+    }
     return finalResult ?? {
       success: false,
       error: { type: "unknown", message: "No result received" }
@@ -24147,6 +24797,7 @@ export {
   writeUserProfile,
   executeAgenticQueryStreaming,
   createClaudeAgentExecutor,
+  createWorkflowHooks,
   SUMMARIZE_SYSTEM_PROMPT,
   buildSummarizePrompt,
   executeInteractiveQueryStreaming,