@looplia/looplia-cli 0.7.3 → 0.7.5

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

@@ -4,10 +4,11 @@ import {
   pathExists
 } from "./chunk-VRBGWKZ6.js";
 import {
+  __export,
   init_esm_shims
 } from "./chunk-Y55L47HC.js";
 
-// ../../packages/provider/dist/chunk-DRG2TRPF.js
+// ../../packages/provider/dist/chunk-5BLYIGE4.js
 init_esm_shims();
 import { createHash } from "crypto";
 import {
@@ -29,7 +30,6 @@ import { promisify } from "util";
 var execAsync = promisify(exec);
 var CORE_SKILLS = [
   "workflow-executor",
-  "workflow-executor-inline",
   "workflow-validator",
   "registry-loader"
 ];
@@ -293,116 +293,123 @@ async function getPluginPaths() {
   return await getProdPluginPaths();
 }
 
-// ../../packages/provider/dist/chunk-3N4TZG2S.js
+// ../../packages/core/dist/index.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 {
-  chmod,
-  mkdir as mkdir3,
-  readFile as readFile2,
-  rename,
-  rm as rm2,
-  writeFile as writeFile2
-} from "fs/promises";
-import { homedir as homedir22 } from "os";
-import { join as join23 } from "path";
-
-// ../../node_modules/zod-to-json-schema/dist/esm/index.js
-init_esm_shims();
-
-// ../../node_modules/zod-to-json-schema/dist/esm/Options.js
-init_esm_shims();
-var ignoreOverride = /* @__PURE__ */ Symbol("Let zodToJsonSchema decide on which parser to use");
-var defaultOptions = {
-  name: void 0,
-  $refStrategy: "root",
-  basePath: ["#"],
-  effectStrategy: "input",
-  pipeStrategy: "all",
-  dateStrategy: "format:date-time",
-  mapStrategy: "entries",
-  removeAdditionalStrategy: "passthrough",
-  allowedAdditionalProperties: true,
-  rejectedAdditionalProperties: false,
-  definitionPath: "definitions",
-  target: "jsonSchema7",
-  strictUnions: false,
-  definitions: {},
-  errorMessages: false,
-  markdownDescription: false,
-  patternStrategy: "escape",
-  applyRegexFlags: false,
-  emailStrategy: "format:email",
-  base64Strategy: "contentEncoding:base64",
-  nameStrategy: "ref",
-  openAiAnyTypeName: "OpenAiAnyType"
-};
-var getDefaultOptions = (options) => typeof options === "string" ? {
-  ...defaultOptions,
-  name: options
-} : {
-  ...defaultOptions,
-  ...options
-};
-
-// ../../node_modules/zod-to-json-schema/dist/esm/Refs.js
-init_esm_shims();
-var getRefs = (options) => {
-  const _options = getDefaultOptions(options);
-  const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
-  return {
-    ..._options,
-    flags: { hasReferencedOpenAiAnyType: false },
-    currentPath,
-    propertyPath: void 0,
-    seen: new Map(Object.entries(_options.definitions).map(([name, def]) => [
-      def._def,
-      {
-        def: def._def,
-        path: [..._options.basePath, _options.definitionPath, name],
-        // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
-        jsonSchema: void 0
-      }
-    ]))
-  };
-};
-
-// ../../node_modules/zod-to-json-schema/dist/esm/errorMessages.js
-init_esm_shims();
-function addErrorMessage(res, key, errorMessage, refs) {
-  if (!refs?.errorMessages)
-    return;
-  if (errorMessage) {
-    res.errorMessage = {
-      ...res.errorMessage,
-      [key]: errorMessage
-    };
-  }
-}
-function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
-  res[key] = value;
-  addErrorMessage(res, key, errorMessage, refs);
-}
-
-// ../../node_modules/zod-to-json-schema/dist/esm/getRelativePath.js
-init_esm_shims();
-var getRelativePath = (pathA, pathB) => {
-  let i = 0;
-  for (; i < pathA.length && i < pathB.length; i++) {
-    if (pathA[i] !== pathB[i])
-      break;
-  }
-  return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
-};
 
-// ../../node_modules/zod-to-json-schema/dist/esm/parseDef.js
+// ../../node_modules/zod/index.js
 init_esm_shims();
 
-// ../../node_modules/zod-to-json-schema/dist/esm/selectParser.js
+// ../../node_modules/zod/v3/external.js
+var external_exports = {};
+__export(external_exports, {
+  BRAND: () => BRAND,
+  DIRTY: () => DIRTY,
+  EMPTY_PATH: () => EMPTY_PATH,
+  INVALID: () => INVALID,
+  NEVER: () => NEVER,
+  OK: () => OK,
+  ParseStatus: () => ParseStatus,
+  Schema: () => ZodType,
+  ZodAny: () => ZodAny,
+  ZodArray: () => ZodArray,
+  ZodBigInt: () => ZodBigInt,
+  ZodBoolean: () => ZodBoolean,
+  ZodBranded: () => ZodBranded,
+  ZodCatch: () => ZodCatch,
+  ZodDate: () => ZodDate,
+  ZodDefault: () => ZodDefault,
+  ZodDiscriminatedUnion: () => ZodDiscriminatedUnion,
+  ZodEffects: () => ZodEffects,
+  ZodEnum: () => ZodEnum,
+  ZodError: () => ZodError,
+  ZodFirstPartyTypeKind: () => ZodFirstPartyTypeKind,
+  ZodFunction: () => ZodFunction,
+  ZodIntersection: () => ZodIntersection,
+  ZodIssueCode: () => ZodIssueCode,
+  ZodLazy: () => ZodLazy,
+  ZodLiteral: () => ZodLiteral,
+  ZodMap: () => ZodMap,
+  ZodNaN: () => ZodNaN,
+  ZodNativeEnum: () => ZodNativeEnum,
+  ZodNever: () => ZodNever,
+  ZodNull: () => ZodNull,
+  ZodNullable: () => ZodNullable,
+  ZodNumber: () => ZodNumber,
+  ZodObject: () => ZodObject,
+  ZodOptional: () => ZodOptional,
+  ZodParsedType: () => ZodParsedType,
+  ZodPipeline: () => ZodPipeline,
+  ZodPromise: () => ZodPromise,
+  ZodReadonly: () => ZodReadonly,
+  ZodRecord: () => ZodRecord,
+  ZodSchema: () => ZodType,
+  ZodSet: () => ZodSet,
+  ZodString: () => ZodString,
+  ZodSymbol: () => ZodSymbol,
+  ZodTransformer: () => ZodEffects,
+  ZodTuple: () => ZodTuple,
+  ZodType: () => ZodType,
+  ZodUndefined: () => ZodUndefined,
+  ZodUnion: () => ZodUnion,
+  ZodUnknown: () => ZodUnknown,
+  ZodVoid: () => ZodVoid,
+  addIssueToContext: () => addIssueToContext,
+  any: () => anyType,
+  array: () => arrayType,
+  bigint: () => bigIntType,
+  boolean: () => booleanType,
+  coerce: () => coerce,
+  custom: () => custom,
+  date: () => dateType,
+  datetimeRegex: () => datetimeRegex,
+  defaultErrorMap: () => en_default,
+  discriminatedUnion: () => discriminatedUnionType,
+  effect: () => effectsType,
+  enum: () => enumType,
+  function: () => functionType,
+  getErrorMap: () => getErrorMap,
+  getParsedType: () => getParsedType,
+  instanceof: () => instanceOfType,
+  intersection: () => intersectionType,
+  isAborted: () => isAborted,
+  isAsync: () => isAsync,
+  isDirty: () => isDirty,
+  isValid: () => isValid,
+  late: () => late,
+  lazy: () => lazyType,
+  literal: () => literalType,
+  makeIssue: () => makeIssue,
+  map: () => mapType,
+  nan: () => nanType,
+  nativeEnum: () => nativeEnumType,
+  never: () => neverType,
+  null: () => nullType,
+  nullable: () => nullableType,
+  number: () => numberType,
+  object: () => objectType,
+  objectUtil: () => objectUtil,
+  oboolean: () => oboolean,
+  onumber: () => onumber,
+  optional: () => optionalType,
+  ostring: () => ostring,
+  pipeline: () => pipelineType,
+  preprocess: () => preprocessType,
+  promise: () => promiseType,
+  quotelessJson: () => quotelessJson,
+  record: () => recordType,
+  set: () => setType,
+  setErrorMap: () => setErrorMap,
+  strictObject: () => strictObjectType,
+  string: () => stringType,
+  symbol: () => symbolType,
+  transformer: () => effectsType,
+  tuple: () => tupleType,
+  undefined: () => undefinedType,
+  union: () => unionType,
+  unknown: () => unknownType,
+  util: () => util,
+  void: () => voidType
+});
 init_esm_shims();
 
 // ../../node_modules/zod/v3/errors.js
@@ -4349,112 +4356,904 @@ var coerce = {
 };
 var NEVER = INVALID;
 
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/any.js
-init_esm_shims();
-function parseAnyDef(refs) {
-  if (refs.target !== "openAi") {
-    return {};
+// ../../packages/core/dist/index.js
+var commands = /* @__PURE__ */ new Map();
+function registerCommand(definition) {
+  if (commands.has(definition.name)) {
+    throw new Error(`Command "${definition.name}" is already registered`);
   }
-  const anyDefinitionPath = [
-    ...refs.basePath,
-    refs.definitionPath,
-    refs.openAiAnyTypeName
-  ];
-  refs.flags.hasReferencedOpenAiAnyType = true;
-  return {
-    $ref: refs.$refStrategy === "relative" ? getRelativePath(anyDefinitionPath, refs.currentPath) : anyDefinitionPath.join("/")
-  };
+  commands.set(definition.name, definition);
 }
+function buildWorkflowPrompt(ctx) {
+  if (!(ctx.workflowName && ctx.workflowDefinition)) {
+    throw new Error(
+      "Workflow context is required (workflowName, workflowDefinition)"
+    );
+  }
+  return `Task: Execute workflow "${ctx.workflowName}" for session: contentItem/${ctx.contentId}
 
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/array.js
-init_esm_shims();
-function parseArrayDef(def, refs) {
-  const res = {
-    type: "array"
+## Workflow Definition
+
+\`\`\`yaml
+${ctx.workflowDefinition}
+\`\`\`
+
+${ctx.workflowInstructions ? `## Custom Instructions
+
+${ctx.workflowInstructions}
+` : ""}
+## Execution Protocol
+
+### Step 1: Read Validation State
+Read \`contentItem/${ctx.contentId}/validation.json\` to understand:
+- What outputs are required
+- Validation criteria for each output
+- Which outputs have already passed validation
+
+If validation.json is missing, the workflow hasn't started properly.
+
+### Step 2: Execute Outputs (Dependency Order)
+
+For each output in the workflow (following dependency order):
+
+1. **Check completion**:
+   - If artifact exists AND validated=true in validation.json \u2192 skip
+
+2. **If incomplete - use Task tool with custom subagent_type**:
+
+   Use the **Task** tool to invoke the agent specified in the workflow definition.
+   The subagent_type MUST match the \`agent\` field exactly from the workflow YAML.
+
+   Example for an output with \`agent: content-analyzer\`:
+   \`\`\`json
+   {
+     "name": "Task",
+     "input": {
+       "subagent_type": "content-analyzer",
+       "description": "Generate summary artifact",
+       "prompt": "Analyze content at contentItem/${ctx.contentId}/content.md and write summary.json"
+     }
+   }
+   \`\`\`
+
+   The subagent will:
+   - Auto-load its configured skills (from .claude/agents/*.md)
+   - Write artifact to \`contentItem/${ctx.contentId}/{artifact}\`
+
+3. **After artifact written - use Skill tool for validation**:
+
+   Use the **Skill** tool to invoke workflow-validator:
+   \`\`\`json
+   {
+     "name": "Skill",
+     "input": { "skill": "workflow-validator" }
+   }
+   \`\`\`
+
+   Then follow the skill's instructions to validate the artifact against criteria.
+
+4. **Handle validation result**:
+   - If passed: Update validation.json \u2192 set \`outputs.{name}.validated = true\`
+   - If failed: Review failed checks, retry subagent with specific feedback
+
+### Step 3: Return Final Output
+
+When the output marked \`final: true\` passes validation:
+1. Read the final artifact JSON
+2. Return it as structured output
+
+## Workspace Structure
+
+- **Content**: \`contentItem/${ctx.contentId}/content.md\`
+- **Validation**: \`contentItem/${ctx.contentId}/validation.json\`
+- **Artifacts**: \`contentItem/${ctx.contentId}/*.json\`
+- **Workflow**: \`workflows/${ctx.workflowName}.md\`
+- **Agents**: \`.claude/agents/*.md\`
+- **Skills**: \`.claude/skills/*/SKILL.md\`
+
+## Important Rules
+
+- **Validate after each step** - Never skip validation
+- **Update validation.json** - Mark outputs validated when passed
+- **Follow dependencies** - Complete required outputs before dependent ones
+- **Retry on failure** - Give subagent specific feedback on validation failures
+- **Return structured JSON** - Final output must match expected schema`;
+}
+var workflowCommand = {
+  name: "workflow",
+  promptTemplate: buildWorkflowPrompt,
+  // Generic object schema - allows any JSON object structure
+  // Must be an object schema (not z.unknown()) to produce valid JSON schema with "type" field
+  outputSchema: external_exports.record(external_exports.string(), external_exports.unknown())
+};
+registerCommand(workflowCommand);
+var RUN_PATTERN = /^agents\/([a-z][a-z0-9-]*)$/;
+function isValidRunFormat(run) {
+  return RUN_PATTERN.test(run);
+}
+var INPUTLESS_CAPABLE_SKILLS = ["browser-research"];
+var ARRAY_PATTERN = /^\[(.*)\]$/;
+var INTEGER_PATTERN = /^\d+$/;
+var NON_SPACE_PATTERN = /\S/;
+var FRONTMATTER_REGEX = /^---\n([\s\S]*?)\n---\n?([\s\S]*)$/;
+function isSkippableLine(line) {
+  const trimmed = line.trim();
+  return !trimmed || trimmed.startsWith("#");
+}
+function parseKeyValue(trimmed) {
+  const colonIndex = trimmed.indexOf(":");
+  if (colonIndex === -1) {
+    return null;
+  }
+  return {
+    key: trimmed.slice(0, colonIndex),
+    value: trimmed.slice(colonIndex + 1).trim()
   };
-  if (def.type?._def && def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny) {
-    res.items = parseDef(def.type._def, {
-      ...refs,
-      currentPath: [...refs.currentPath, "items"]
-    });
+}
+function parseArray(value) {
+  const match = value.match(ARRAY_PATTERN);
+  if (match?.[1] !== void 0) {
+    return match[1].split(",").map((s) => s.trim());
   }
-  if (def.minLength) {
-    setResponseValueAndErrors(res, "minItems", def.minLength.value, def.minLength.message, refs);
+  return null;
+}
+function stripQuotes(value) {
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
   }
-  if (def.maxLength) {
-    setResponseValueAndErrors(res, "maxItems", def.maxLength.value, def.maxLength.message, refs);
+  return value;
+}
+function parseYamlValue(value) {
+  const array2 = parseArray(value);
+  if (array2) {
+    return array2;
   }
-  if (def.exactLength) {
-    setResponseValueAndErrors(res, "minItems", def.exactLength.value, def.exactLength.message, refs);
-    setResponseValueAndErrors(res, "maxItems", def.exactLength.value, def.exactLength.message, refs);
+  if (value === "true") {
+    return true;
   }
-  return res;
+  if (value === "false") {
+    return false;
+  }
+  if (INTEGER_PATTERN.test(value)) {
+    return Number.parseInt(value, 10);
+  }
+  return stripQuotes(value);
 }
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/bigint.js
-init_esm_shims();
-function parseBigintDef(def, refs) {
-  const res = {
-    type: "integer",
-    format: "int64"
-  };
-  if (!def.checks)
-    return res;
-  for (const check2 of def.checks) {
-    switch (check2.kind) {
-      case "min":
-        if (refs.target === "jsonSchema7") {
-          if (check2.inclusive) {
-            setResponseValueAndErrors(res, "minimum", check2.value, check2.message, refs);
-          } else {
-            setResponseValueAndErrors(res, "exclusiveMinimum", check2.value, check2.message, refs);
-          }
-        } else {
-          if (!check2.inclusive) {
-            res.exclusiveMinimum = true;
-          }
-          setResponseValueAndErrors(res, "minimum", check2.value, check2.message, refs);
-        }
-        break;
-      case "max":
-        if (refs.target === "jsonSchema7") {
-          if (check2.inclusive) {
-            setResponseValueAndErrors(res, "maximum", check2.value, check2.message, refs);
-          } else {
-            setResponseValueAndErrors(res, "exclusiveMaximum", check2.value, check2.message, refs);
-          }
-        } else {
-          if (!check2.inclusive) {
-            res.exclusiveMaximum = true;
-          }
-          setResponseValueAndErrors(res, "maximum", check2.value, check2.message, refs);
-        }
-        break;
-      case "multipleOf":
-        setResponseValueAndErrors(res, "multipleOf", check2.value, check2.message, refs);
-        break;
+function processYamlLine(state, line) {
+  if (isSkippableLine(line)) {
+    return;
+  }
+  const indent = line.search(NON_SPACE_PATTERN);
+  const trimmed = line.trim();
+  if (indent === 0) {
+    processTopLevel(state, trimmed);
+  } else if (indent === 2 && state.currentKey === "skills") {
+    processSkillItem(state, trimmed);
+  } else if (indent === 2 && state.currentKey === "inputs") {
+    processInputItem(state, trimmed);
+  } else if (indent === 2 && state.currentKey === "steps") {
+    processStepItem(state, trimmed);
+  } else if (indent === 4 && state.currentInput) {
+    processInputProperty(state, trimmed);
+  } else if (indent === 4 && state.currentStep) {
+    processStepProperty(state, trimmed);
+  } else if (indent === 6 && state.currentValidate) {
+    processValidateProperty(state, trimmed);
+  }
+}
+function processSkillItem(state, trimmed) {
+  if (trimmed.startsWith("- ")) {
+    const skillName = trimmed.slice(2).trim();
+    if (skillName) {
+      state.skills.push(skillName);
+    }
+  }
+}
+function processTopLevel(state, trimmed) {
+  if (state.currentStep?.id) {
+    state.steps.push(state.currentStep);
+    state.currentStep = null;
+  }
+  if (state.currentInput?.name) {
+    state.inputs.push(state.currentInput);
+    state.currentInput = null;
+  }
+  const kv = parseKeyValue(trimmed);
+  if (!kv) {
+    return;
+  }
+  state.currentKey = kv.key;
+  if (kv.key !== "steps" && kv.key !== "inputs" && kv.key !== "skills" && kv.value) {
+    state.result[kv.key] = kv.value;
+  }
+  state.currentValidate = null;
+}
+function processInputItem(state, trimmed) {
+  if (trimmed.startsWith("- ")) {
+    if (state.currentInput?.name) {
+      state.inputs.push(state.currentInput);
+    }
+    state.currentInput = {};
+    const firstProp = trimmed.slice(2).trim();
+    const kv = parseKeyValue(firstProp);
+    if (kv) {
+      handleInputProperty(state.currentInput, kv.key, kv.value);
     }
   }
-  return res;
 }
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/boolean.js
-init_esm_shims();
-function parseBooleanDef() {
-  return {
-    type: "boolean"
-  };
+function handleInputProperty(input, key, value) {
+  switch (key) {
+    case "name":
+      input.name = value;
+      break;
+    case "required":
+      input.required = value === "true";
+      break;
+    case "description":
+      input.description = value;
+      break;
+    case "type":
+      if (value === "file" || value === "json") {
+        input.type = value;
+      }
+      break;
+    default:
+      break;
+  }
 }
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/branded.js
-init_esm_shims();
-function parseBrandedDef(_def, refs) {
-  return parseDef(_def.type._def, refs);
+function processInputProperty(state, trimmed) {
+  if (!state.currentInput) {
+    return;
+  }
+  const kv = parseKeyValue(trimmed);
+  if (!kv) {
+    return;
+  }
+  handleInputProperty(state.currentInput, kv.key, kv.value);
 }
-
-// ../../node_modules/zod-to-json-schema/dist/esm/parsers/catch.js
-init_esm_shims();
-var parseCatchDef = (def, refs) => {
+function processStepItem(state, trimmed) {
+  if (trimmed.startsWith("- ")) {
+    if (state.currentStep?.id) {
+      state.steps.push(state.currentStep);
+    }
+    state.currentStep = {};
+    state.currentValidate = null;
+    const firstProp = trimmed.slice(2).trim();
+    const kv = parseKeyValue(firstProp);
+    if (kv) {
+      handleStepProperty(state.currentStep, kv.key, kv.value);
+    }
+  }
+}
+function handleStepProperty(step, key, value) {
+  switch (key) {
+    case "id":
+      step.id = value;
+      break;
+    case "skill":
+      step.skill = value;
+      break;
+    case "mission":
+      step.mission = value;
+      break;
+    case "run":
+      step.run = value;
+      break;
+    case "input": {
+      const arr = parseArray(value);
+      step.input = arr ?? value;
+      break;
+    }
+    case "output":
+      step.output = value;
+      break;
+    case "needs": {
+      const arr = parseArray(value);
+      if (arr) {
+        step.needs = arr;
+      }
+      break;
+    }
+    case "final":
+      step.final = value === "true";
+      break;
+    case "validate": {
+      const validate = {};
+      step.validate = validate;
+      return validate;
+    }
+    default:
+      break;
+  }
+  return null;
+}
+function processStepProperty(state, trimmed) {
+  if (!state.currentStep) {
+    return;
+  }
+  const kv = parseKeyValue(trimmed);
+  if (!kv) {
+    return;
+  }
+  const validate = handleStepProperty(state.currentStep, kv.key, kv.value);
+  if (validate) {
+    state.currentValidate = validate;
+  }
+}
+function processValidateProperty(state, trimmed) {
+  if (!state.currentValidate) {
+    return;
+  }
+  const kv = parseKeyValue(trimmed);
+  if (!kv) {
+    return;
+  }
+  state.currentValidate[kv.key] = parseYamlValue(kv.value);
+}
+function parseFrontmatter(content) {
+  const match = content.match(FRONTMATTER_REGEX);
+  if (!match) {
+    throw new Error(
+      "Invalid workflow file: missing YAML frontmatter (must start with ---)"
+    );
+  }
+  const yamlContent = match[1] ?? "";
+  const body = match[2] ?? "";
+  const frontmatter = parseSimpleYaml(yamlContent);
+  return { frontmatter, body: body.trim() };
+}
+function parseSimpleYaml(yaml) {
+  const state = {
+    result: {},
+    steps: [],
+    inputs: [],
+    skills: [],
+    currentKey: "",
+    currentStep: null,
+    currentInput: null,
+    currentValidate: null
+  };
+  for (const line of yaml.split("\n")) {
+    processYamlLine(state, line);
+  }
+  if (state.currentInput?.name) {
+    state.inputs.push(state.currentInput);
+  }
+  if (state.currentStep?.id) {
+    state.steps.push(state.currentStep);
+  }
+  if (state.skills.length > 0) {
+    state.result.skills = state.skills;
+  }
+  if (state.inputs.length > 0) {
+    state.result.inputs = state.inputs;
+  }
+  if (state.steps.length > 0) {
+    state.result.steps = state.steps;
+  }
+  return state.result;
+}
+var INPUT_REFERENCE_PATTERN = /\$\{\{\s*inputs\.(\w[\w-]*)\s*\}\}/g;
+function validateInputReferences(input, workflowInputs) {
+  const inputs = Array.isArray(input) ? input : [input];
+  const declaredNames = new Set(
+    workflowInputs.filter((i) => i.name).map((i) => i.name)
+  );
+  for (const inp of inputs) {
+    const matches = inp.matchAll(INPUT_REFERENCE_PATTERN);
+    for (const match of matches) {
+      const referencedName = match[1];
+      if (referencedName && !declaredNames.has(referencedName)) {
+        throw new Error(
+          `Unknown input reference: inputs.${referencedName}. Declared inputs: ${[...declaredNames].join(", ") || "(none)"}`
+        );
+      }
+    }
+  }
+}
+function validateStepExecutionMode(step) {
+  const hasSkill = Boolean(step.skill && step.mission);
+  const hasRun = Boolean(step.run);
+  if (!(hasSkill || hasRun)) {
+    throw new Error(
+      `Step '${step.id}' must have either 'skill' + 'mission' (v0.6.1) or 'run' (v0.6.0 deprecated)`
+    );
+  }
+  if (hasSkill && hasRun) {
+    throw new Error(
+      `Step '${step.id}' cannot have both 'skill' and 'run' - use one or the other`
+    );
+  }
+  if (hasRun && step.run && !isValidRunFormat(step.run)) {
+    throw new Error(
+      `Step '${step.id}' has invalid run format '${step.run}'. Expected 'agents/{name}' where name is lowercase alphanumeric with hyphens.`
+    );
+  }
+}
+function validateStep(step, workflowInputs = []) {
+  if (!step.id) {
+    throw new Error("Each step must have an 'id' field");
+  }
+  validateStepExecutionMode(step);
+  const isInputlessCapable = step.skill && INPUTLESS_CAPABLE_SKILLS.includes(step.skill);
+  if (!(step.input || isInputlessCapable)) {
+    throw new Error(
+      `Step '${step.id}' must have an 'input' field (or use an input-less capable skill like: ${INPUTLESS_CAPABLE_SKILLS.join(", ")})`
+    );
+  }
+  if (Array.isArray(step.input) && step.input.length === 0) {
+    throw new Error(`Step '${step.id}' input array cannot be empty`);
+  }
+  if (step.input && workflowInputs.length > 0) {
+    validateInputReferences(step.input, workflowInputs);
+  }
+  if (!step.output) {
+    throw new Error(`Step '${step.id}' must have an 'output' field`);
+  }
+}
+function parseWorkflow(content) {
+  const { frontmatter, body } = parseFrontmatter(content);
+  if (!frontmatter.name || typeof frontmatter.name !== "string") {
+    throw new Error("Workflow must have a 'name' field");
+  }
+  if (!frontmatter.description || typeof frontmatter.description !== "string") {
+    throw new Error("Workflow must have a 'description' field");
+  }
+  if (!(frontmatter.steps && Array.isArray(frontmatter.steps)) || frontmatter.steps.length === 0) {
+    throw new Error("Workflow must have at least one step defined");
+  }
+  const workflowInputs = Array.isArray(frontmatter.inputs) ? frontmatter.inputs : [];
+  const workflowSkills = Array.isArray(frontmatter.skills) ? frontmatter.skills : [];
+  for (const step of frontmatter.steps) {
+    validateStep(step, workflowInputs);
+  }
+  const inputs = workflowInputs.filter((inp) => inp.name).map((inp) => ({
+    name: inp.name,
+    required: inp.required ?? true,
+    description: inp.description,
+    type: inp.type
+  }));
+  return {
+    definition: {
+      name: frontmatter.name,
+      version: frontmatter.version,
+      description: frontmatter.description,
+      skills: workflowSkills.length > 0 ? workflowSkills : void 0,
+      inputs: inputs.length > 0 ? inputs : void 0,
+      steps: frontmatter.steps
+    },
+    instructions: body
+  };
+}
+function generateValidationManifest(definition) {
+  const steps = {};
+  for (const step of definition.steps) {
+    steps[step.id] = {
+      output: step.output,
+      validate: step.validate,
+      validated: false
+    };
+  }
+  return {
+    workflow: definition.name,
+    version: definition.version,
+    finalStepId: getFinalStep(definition),
+    steps
+  };
+}
+function getExecutionOrder(definition) {
+  const stepsMap = new Map(definition.steps.map((s) => [s.id, s]));
+  const order = [];
+  const visited = /* @__PURE__ */ new Set();
+  const visiting = /* @__PURE__ */ new Set();
+  function visit(id) {
+    if (visited.has(id)) {
+      return;
+    }
+    if (visiting.has(id)) {
+      throw new Error(`Circular dependency detected: ${id}`);
+    }
+    visiting.add(id);
+    const step = stepsMap.get(id);
+    if (step?.needs) {
+      for (const dep of step.needs) {
+        if (!stepsMap.has(dep)) {
+          throw new Error(`Unknown dependency '${dep}' in step '${id}'`);
+        }
+        visit(dep);
+      }
+    }
+    visiting.delete(id);
+    visited.add(id);
+    order.push(id);
+  }
+  for (const step of definition.steps) {
+    visit(step.id);
+  }
+  return order;
+}
+function getFinalStep(definition) {
+  for (const step of definition.steps) {
+    if (step.final) {
+      return step.id;
+    }
+  }
+  const order = getExecutionOrder(definition);
+  const lastStep = order.at(-1);
+  if (!lastStep) {
+    throw new Error("Workflow has no steps");
+  }
+  return lastStep;
+}
+function isInputlessWorkflow(definition) {
+  if (definition.inputs?.some((input) => input.required)) {
+    return false;
+  }
+  const firstSteps = definition.steps.filter(
+    (step) => !step.needs || step.needs.length === 0
+  );
+  if (firstSteps.length === 0) {
+    return false;
+  }
+  return firstSteps.every(
+    (step) => step.skill && INPUTLESS_CAPABLE_SKILLS.includes(step.skill)
+  );
+}
+function extractWorkflowSkills(workflow) {
+  if (workflow.definition.skills && workflow.definition.skills.length > 0) {
+    return workflow.definition.skills;
+  }
+  const skills = /* @__PURE__ */ new Set();
+  for (const step of workflow.definition.steps) {
+    if (step.skill) {
+      skills.add(step.skill);
+    }
+  }
+  return [...skills];
+}
+var SourceTypeSchema = external_exports.enum([
+  "rss",
+  "youtube",
+  "podcast",
+  "twitter",
+  "custom"
+]);
+var SourceSchema = external_exports.object({
+  id: external_exports.string().min(1),
+  type: SourceTypeSchema,
+  label: external_exports.string().optional(),
+  url: external_exports.string(),
+  metadata: external_exports.record(external_exports.unknown()).optional()
+});
+var ContentMetadataSchema = external_exports.object({
+  language: external_exports.string().length(2).optional(),
+  durationSeconds: external_exports.number().positive().optional(),
+  author: external_exports.string().optional(),
+  wordCount: external_exports.number().positive().optional()
+}).passthrough();
+var ContentItemSchema = external_exports.object({
+  id: external_exports.string().min(1),
+  source: SourceSchema,
+  title: external_exports.string().min(1),
+  url: external_exports.string(),
+  publishedAt: external_exports.string().optional(),
+  rawText: external_exports.string().min(1),
+  metadata: ContentMetadataSchema
+});
+var ValidationCriteriaSchema = external_exports.object({
+  required_fields: external_exports.array(external_exports.string()).optional(),
+  min_quotes: external_exports.number().int().positive().optional(),
+  min_key_points: external_exports.number().int().positive().optional(),
+  min_outline_sections: external_exports.number().int().positive().optional(),
+  has_hooks: external_exports.boolean().optional()
+}).passthrough();
+var WorkflowInputSchema = external_exports.object({
+  name: external_exports.string().min(1).regex(/^[a-z][a-z0-9-]*$/, "Input name must be kebab-case"),
+  required: external_exports.boolean(),
+  description: external_exports.string().optional(),
+  type: external_exports.enum(["file", "json"]).optional()
+});
+var WorkflowStepSchema = external_exports.object({
+  id: external_exports.string().min(1),
+  skill: external_exports.string().min(1).optional(),
+  mission: external_exports.string().min(1).optional(),
+  run: external_exports.string().min(1).optional(),
+  input: external_exports.union([external_exports.string(), external_exports.array(external_exports.string())]).optional(),
+  output: external_exports.string().min(1),
+  needs: external_exports.array(external_exports.string()).optional(),
+  final: external_exports.boolean().optional(),
+  validate: ValidationCriteriaSchema.optional()
+}).refine(
+  (step) => step.skill && step.mission || step.run,
+  "Step must have either 'skill' + 'mission' or 'run'"
+).refine(
+  (step) => !(step.skill && step.run),
+  "Step cannot have both 'skill' and 'run'"
+);
+var WorkflowDefinitionSchema = external_exports.object({
+  name: external_exports.string().min(1),
+  version: external_exports.string().optional(),
+  description: external_exports.string().min(1),
+  inputs: external_exports.array(WorkflowInputSchema).optional(),
+  steps: external_exports.array(WorkflowStepSchema)
+});
+var StepValidationStateSchema = external_exports.object({
+  output: external_exports.string().min(1),
+  validate: ValidationCriteriaSchema.optional(),
+  validated: external_exports.boolean()
+});
+var ValidationManifestSchema = external_exports.object({
+  workflow: external_exports.string().min(1),
+  version: external_exports.string().optional(),
+  sandboxId: external_exports.string().optional(),
+  createdAt: external_exports.string().optional(),
+  finalStepId: external_exports.string().optional(),
+  steps: external_exports.record(external_exports.string(), StepValidationStateSchema)
+});
+var ValidationCheckSchema = external_exports.object({
+  name: external_exports.string().min(1),
+  passed: external_exports.boolean(),
+  message: external_exports.string()
+});
+var ValidationResultSchema = external_exports.object({
+  passed: external_exports.boolean(),
+  checks: external_exports.array(ValidationCheckSchema)
+});
+var SessionManifestSchema = external_exports.object({
+  version: external_exports.literal(1),
+  contentId: external_exports.string().min(1),
+  pipeline: external_exports.string().min(1),
+  desiredOutput: external_exports.string().min(1),
+  updatedAt: external_exports.string(),
+  steps: external_exports.record(external_exports.string(), external_exports.literal("done"))
+});
+var UserTopicSchema = external_exports.object({
+  topic: external_exports.string().min(1),
+  interestLevel: external_exports.union([
+    external_exports.literal(1),
+    external_exports.literal(2),
+    external_exports.literal(3),
+    external_exports.literal(4),
+    external_exports.literal(5)
+  ])
+});
+var WritingStyleSchema = external_exports.object({
+  tone: external_exports.enum(["beginner", "intermediate", "expert", "mixed"]),
+  targetWordCount: external_exports.number().min(100).max(1e4),
+  voice: external_exports.enum(["first-person", "third-person", "instructional"])
+});
+var UserProfileSchema = external_exports.object({
+  userId: external_exports.string().min(1),
+  topics: external_exports.array(UserTopicSchema),
+  style: WritingStyleSchema,
+  writingSamples: external_exports.array(external_exports.string()).optional()
+});
+function validateUserProfile(data) {
+  const result = UserProfileSchema.safeParse(data);
+  if (result.success) {
+    return { success: true, data: result.data };
+  }
+  return { success: false, error: { message: result.error.message } };
+}
+
+// ../../packages/provider/dist/chunk-W4MDOBYT.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 {
+  chmod,
+  mkdir as mkdir3,
+  readFile as readFile2,
+  rename,
+  rm as rm2,
+  writeFile as writeFile2
+} from "fs/promises";
+import { homedir as homedir22 } from "os";
+import { join as join23 } from "path";
+
+// ../../node_modules/zod-to-json-schema/dist/esm/index.js
+init_esm_shims();
+
+// ../../node_modules/zod-to-json-schema/dist/esm/Options.js
+init_esm_shims();
+var ignoreOverride = /* @__PURE__ */ Symbol("Let zodToJsonSchema decide on which parser to use");
+var defaultOptions = {
+  name: void 0,
+  $refStrategy: "root",
+  basePath: ["#"],
+  effectStrategy: "input",
+  pipeStrategy: "all",
+  dateStrategy: "format:date-time",
+  mapStrategy: "entries",
+  removeAdditionalStrategy: "passthrough",
+  allowedAdditionalProperties: true,
+  rejectedAdditionalProperties: false,
+  definitionPath: "definitions",
+  target: "jsonSchema7",
+  strictUnions: false,
+  definitions: {},
+  errorMessages: false,
+  markdownDescription: false,
+  patternStrategy: "escape",
+  applyRegexFlags: false,
+  emailStrategy: "format:email",
+  base64Strategy: "contentEncoding:base64",
+  nameStrategy: "ref",
+  openAiAnyTypeName: "OpenAiAnyType"
+};
+var getDefaultOptions = (options) => typeof options === "string" ? {
+  ...defaultOptions,
+  name: options
+} : {
+  ...defaultOptions,
+  ...options
+};
+
+// ../../node_modules/zod-to-json-schema/dist/esm/Refs.js
+init_esm_shims();
+var getRefs = (options) => {
+  const _options = getDefaultOptions(options);
+  const currentPath = _options.name !== void 0 ? [..._options.basePath, _options.definitionPath, _options.name] : _options.basePath;
+  return {
+    ..._options,
+    flags: { hasReferencedOpenAiAnyType: false },
+    currentPath,
+    propertyPath: void 0,
+    seen: new Map(Object.entries(_options.definitions).map(([name, def]) => [
+      def._def,
+      {
+        def: def._def,
+        path: [..._options.basePath, _options.definitionPath, name],
+        // Resolution of references will be forced even though seen, so it's ok that the schema is undefined here for now.
+        jsonSchema: void 0
+      }
+    ]))
+  };
+};
+
+// ../../node_modules/zod-to-json-schema/dist/esm/errorMessages.js
+init_esm_shims();
+function addErrorMessage(res, key, errorMessage, refs) {
+  if (!refs?.errorMessages)
+    return;
+  if (errorMessage) {
+    res.errorMessage = {
+      ...res.errorMessage,
+      [key]: errorMessage
+    };
+  }
+}
+function setResponseValueAndErrors(res, key, value, errorMessage, refs) {
+  res[key] = value;
+  addErrorMessage(res, key, errorMessage, refs);
+}
+
+// ../../node_modules/zod-to-json-schema/dist/esm/getRelativePath.js
+init_esm_shims();
+var getRelativePath = (pathA, pathB) => {
+  let i = 0;
+  for (; i < pathA.length && i < pathB.length; i++) {
+    if (pathA[i] !== pathB[i])
+      break;
+  }
+  return [(pathA.length - i).toString(), ...pathB.slice(i)].join("/");
+};
+
+// ../../node_modules/zod-to-json-schema/dist/esm/parseDef.js
+init_esm_shims();
+
+// ../../node_modules/zod-to-json-schema/dist/esm/selectParser.js
+init_esm_shims();
+
+// ../../node_modules/zod-to-json-schema/dist/esm/parsers/any.js
+init_esm_shims();
+function parseAnyDef(refs) {
+  if (refs.target !== "openAi") {
+    return {};
+  }
+  const anyDefinitionPath = [
+    ...refs.basePath,
+    refs.definitionPath,
+    refs.openAiAnyTypeName
+  ];
+  refs.flags.hasReferencedOpenAiAnyType = true;
+  return {
+    $ref: refs.$refStrategy === "relative" ? getRelativePath(anyDefinitionPath, refs.currentPath) : anyDefinitionPath.join("/")
+  };
+}
+
+// ../../node_modules/zod-to-json-schema/dist/esm/parsers/array.js
+init_esm_shims();
+function parseArrayDef(def, refs) {
+  const res = {
+    type: "array"
+  };
+  if (def.type?._def && def.type?._def?.typeName !== ZodFirstPartyTypeKind.ZodAny) {
+    res.items = parseDef(def.type._def, {
+      ...refs,
+      currentPath: [...refs.currentPath, "items"]
+    });
+  }
+  if (def.minLength) {
+    setResponseValueAndErrors(res, "minItems", def.minLength.value, def.minLength.message, refs);
+  }
+  if (def.maxLength) {
+    setResponseValueAndErrors(res, "maxItems", def.maxLength.value, def.maxLength.message, refs);
+  }
+  if (def.exactLength) {
+    setResponseValueAndErrors(res, "minItems", def.exactLength.value, def.exactLength.message, refs);
+    setResponseValueAndErrors(res, "maxItems", def.exactLength.value, def.exactLength.message, refs);
+  }
+  return res;
+}
+
+// ../../node_modules/zod-to-json-schema/dist/esm/parsers/bigint.js
+init_esm_shims();
+function parseBigintDef(def, refs) {
+  const res = {
+    type: "integer",
+    format: "int64"
+  };
+  if (!def.checks)
+    return res;
+  for (const check2 of def.checks) {
+    switch (check2.kind) {
+      case "min":
+        if (refs.target === "jsonSchema7") {
+          if (check2.inclusive) {
+            setResponseValueAndErrors(res, "minimum", check2.value, check2.message, refs);
+          } else {
+            setResponseValueAndErrors(res, "exclusiveMinimum", check2.value, check2.message, refs);
+          }
+        } else {
+          if (!check2.inclusive) {
+            res.exclusiveMinimum = true;
+          }
+          setResponseValueAndErrors(res, "minimum", check2.value, check2.message, refs);
+        }
+        break;
+      case "max":
+        if (refs.target === "jsonSchema7") {
+          if (check2.inclusive) {
+            setResponseValueAndErrors(res, "maximum", check2.value, check2.message, refs);
+          } else {
+            setResponseValueAndErrors(res, "exclusiveMaximum", check2.value, check2.message, refs);
+          }
+        } else {
+          if (!check2.inclusive) {
+            res.exclusiveMaximum = true;
+          }
+          setResponseValueAndErrors(res, "maximum", check2.value, check2.message, refs);
+        }
+        break;
+      case "multipleOf":
+        setResponseValueAndErrors(res, "multipleOf", check2.value, check2.message, refs);
+        break;
+    }
+  }
+  return res;
+}
+
+// ../../node_modules/zod-to-json-schema/dist/esm/parsers/boolean.js
+init_esm_shims();
+function parseBooleanDef() {
+  return {
+    type: "boolean"
+  };
+}
+
+// ../../node_modules/zod-to-json-schema/dist/esm/parsers/branded.js
+init_esm_shims();
+function parseBrandedDef(_def, refs) {
+  return parseDef(_def.type._def, refs);
+}
+
+// ../../node_modules/zod-to-json-schema/dist/esm/parsers/catch.js
+init_esm_shims();
+var parseCatchDef = (def, refs) => {
   return parseDef(def.innerType._def, refs);
 };
 
@@ -5592,6 +6391,9 @@ var zodToJsonSchema = (schema, options) => {
   return combined;
 };
 
+// ../../packages/provider/dist/chunk-W4MDOBYT.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";
@@ -5628,7 +6430,7 @@ var __toESM = (mod, isNodeMode, target) => {
   return to;
 };
 var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-var __export = (target, all) => {
+var __export2 = (target, all) => {
   for (var name in all)
     __defProp(target, name, {
       get: all[name],
@@ -17600,7 +18402,7 @@ function config(newConfig) {
   return globalConfig;
 }
 var exports_util = {};
-__export(exports_util, {
+__export2(exports_util, {
   unwrapMessage: () => unwrapMessage,
   stringifyPrimitive: () => stringifyPrimitive,
   required: () => required,
@@ -20528,7 +21330,7 @@ function _refine(Class2, fn, _params) {
   return schema;
 }
 var exports_iso2 = {};
-__export(exports_iso2, {
+__export2(exports_iso2, {
   time: () => time2,
   duration: () => duration2,
   datetime: () => datetime2,
@@ -22127,12 +22929,27 @@ function query({
   return queryInstance;
 }
 
-// ../../packages/provider/dist/chunk-3N4TZG2S.js
+// ../../packages/provider/dist/chunk-W4MDOBYT.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 { readdir as readdir22, 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,
+  readFile as readFile5,
+  rename as rename3,
+  stat as stat3,
+  unlink,
+  writeFile as writeFile4
+} from "fs/promises";
+import { join as join8 } from "path";
+import { join as join9 } from "path";
 var LINE_SPLIT_REGEX = /\r?\n/;
 function findSdkBundledCliPath() {
   try {
@@ -22226,11 +23043,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 +23101,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 +23230,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 +23323,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 +23382,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 +23406,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 +23426,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);
   }
 }
@@ -22640,58 +23570,261 @@ function mapException(error2) {
     };
   }
   return {
-    success: false,
-    error: {
-      type: "unknown",
-      message: String(error2)
+    success: false,
+    error: {
+      type: "unknown",
+      message: String(error2)
+    }
+  };
+}
+var SANDBOX_ID_REGEX = /sandbox\/([^\s/]+)/;
+var CONTENT_ID_REGEX = /contentItem\/([^\s/]+)/;
+var SANDBOX_ARG_REGEX = /--sandbox-id\s+([^\s]+)/;
+var SANDBOX_RESUME_REGEX = /--sandbox\s+([^\s]+)/;
+var VALID_SANDBOX_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
+function extractSandboxIdFromPrompt(prompt) {
+  let match = prompt.match(SANDBOX_ID_REGEX);
+  if (!match) {
+    match = prompt.match(SANDBOX_ARG_REGEX);
+  }
+  if (!match) {
+    match = prompt.match(SANDBOX_RESUME_REGEX);
+  }
+  if (!match) {
+    match = prompt.match(CONTENT_ID_REGEX);
+  }
+  const rawId = match?.[1];
+  if (!rawId) {
+    return null;
+  }
+  let decodedId;
+  try {
+    decodedId = decodeURIComponent(rawId);
+  } catch {
+    return null;
+  }
+  if (decodedId.includes("\0")) {
+    return null;
+  }
+  if (decodedId.includes("..") || decodedId.includes("/") || decodedId.includes("\\")) {
+    return null;
+  }
+  if (!VALID_SANDBOX_ID_PATTERN.test(decodedId)) {
+    return null;
+  }
+  return decodedId;
+}
+var extractContentIdFromPrompt = extractSandboxIdFromPrompt;
+var LOCK_MAX_RETRIES = 5;
+var LOCK_RETRY_DELAY_MS = 200;
+function isBuildManifest(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const obj = value;
+  return obj.type === "build";
+}
+function isRunValidationManifest(value) {
+  if (!value || typeof value !== "object") {
+    return false;
+  }
+  const obj = value;
+  return typeof obj.workflow === "string" && typeof obj.steps === "object" && obj.steps !== null;
+}
+function isValidationManifest(value) {
+  return isBuildManifest(value) || isRunValidationManifest(value);
+}
+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) };
+  }
+}
+function extractBuildResult(manifest, sandboxDir) {
+  if (!manifest.workflowValidated) {
+    return validationError("build", manifest.error ?? "Workflow not validated");
+  }
+  return {
+    success: true,
+    data: {
+      status: "success",
+      sandboxId: manifest.sandboxId ?? sandboxDir.split("/").pop(),
+      workflowName: manifest.workflowName,
+      workflowPath: manifest.workflowPath
     }
   };
 }
-var SANDBOX_ID_REGEX = /sandbox\/([^\s/]+)/;
-var CONTENT_ID_REGEX = /contentItem\/([^\s/]+)/;
-var SANDBOX_ARG_REGEX = /--sandbox-id\s+([^\s]+)/;
-var SANDBOX_RESUME_REGEX = /--sandbox\s+([^\s]+)/;
-var VALID_SANDBOX_ID_PATTERN = /^[a-zA-Z0-9_-]+$/;
-function extractSandboxIdFromPrompt(prompt) {
-  let match = prompt.match(SANDBOX_ID_REGEX);
-  if (!match) {
-    match = prompt.match(SANDBOX_ARG_REGEX);
-  }
-  if (!match) {
-    match = prompt.match(SANDBOX_RESUME_REGEX);
-  }
-  if (!match) {
-    match = prompt.match(CONTENT_ID_REGEX);
+async function extractRunResult(manifest, sandboxDir) {
+  const { allValidated, pendingSteps } = areAllStepsValidated(manifest.steps);
+  if (!allValidated) {
+    return validationError(
+      "steps",
+      `Workflow incomplete. Pending steps: ${pendingSteps.join(", ")}`
+    );
   }
-  const rawId = match?.[1];
-  if (!rawId) {
-    return null;
+  const finalStep = resolveFinalStep(manifest.steps, manifest.finalStepId);
+  if (!finalStep) {
+    return validationError("steps", "No steps found in validation manifest");
   }
-  let decodedId;
-  try {
-    decodedId = decodeURIComponent(rawId);
-  } catch {
-    return null;
+  const { artifact, error: artifactError } = await readFinalArtifact(
+    sandboxDir,
+    finalStep.output
+  );
+  if (artifactError) {
+    return artifactError;
   }
-  if (decodedId.includes("\0")) {
-    return null;
+  return {
+    success: true,
+    data: {
+      status: "success",
+      sandboxId: manifest.sandboxId ?? sandboxDir.split("/").pop(),
+      workflowId: manifest.workflow,
+      artifact
+    }
+  };
+}
+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);
   }
-  if (decodedId.includes("..") || decodedId.includes("/") || decodedId.includes("\\")) {
-    return null;
+  const { manifest, error: readError } = await readValidationManifest(sandboxDir);
+  if (!manifest) {
+    return validationError("validation.json", readError ?? "Unknown error");
   }
-  if (!VALID_SANDBOX_ID_PATTERN.test(decodedId)) {
-    return null;
+  if (isBuildManifest(manifest)) {
+    return extractBuildResult(manifest, sandboxDir);
   }
-  return decodedId;
+  return extractRunResult(manifest, sandboxDir);
 }
-var extractContentIdFromPrompt = extractSandboxIdFromPrompt;
 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 +23833,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 +23881,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 +23918,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 +24012,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 +24035,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 +24045,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 +24525,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 +24597,15 @@ 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 },
+        // v0.7.5: Pass buildHooks from config if provided (build validation)
+        // Only the build command passes hooks - validates workflow file structure
+        ...config2?.buildHooks && { hooks: config2.buildHooks }
       }
     });
     let finalResult;
@@ -23489,6 +24629,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 +24779,519 @@ function createClaudeAgentExecutor(config2) {
     }
   };
 }
+var DEBUG = process.env.LOOPLIA_DEBUG === "1";
+function isWorkflowFile(filePath) {
+  if (!filePath) {
+    return false;
+  }
+  return filePath.includes("/workflows/") && filePath.endsWith(".md");
+}
+function resolveSandboxRoot(context) {
+  return context?.sandboxRoot ?? join7(getLoopliaPluginPath(), "sandbox");
+}
+async function findMostRecentBuildSandbox(sandboxRoot) {
+  try {
+    const entries = await readdir22(sandboxRoot, { withFileTypes: true });
+    const dirs = entries.filter(
+      (e) => e.isDirectory() && e.name.startsWith("build-")
+    );
+    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 resolveSandboxDir2(context) {
+  const sandboxRoot = resolveSandboxRoot(context);
+  if (context?.sandboxId) {
+    return join7(sandboxRoot, context.sandboxId);
+  }
+  return await findMostRecentBuildSandbox(sandboxRoot);
+}
+async function readBuildValidation(context) {
+  const sandboxDir = await resolveSandboxDir2(context);
+  if (!sandboxDir) {
+    if (DEBUG) {
+      console.error("[build-hooks] readBuildValidation: no sandbox dir found");
+    }
+    return;
+  }
+  const validationPath = join7(sandboxDir, "validation.json");
+  try {
+    const content = await readFile4(validationPath, "utf-8");
+    const manifest = JSON.parse(content);
+    if (manifest.type === "build") {
+      return manifest;
+    }
+    return;
+  } catch {
+    return;
+  }
+}
+async function updateBuildValidation(context, updates) {
+  const sandboxDir = await resolveSandboxDir2(context);
+  if (!sandboxDir) {
+    if (DEBUG) {
+      console.error(
+        "[build-hooks] updateBuildValidation: no sandbox dir found"
+      );
+    }
+    return;
+  }
+  const validationPath = join7(sandboxDir, "validation.json");
+  try {
+    const content = await readFile4(validationPath, "utf-8");
+    const manifest = JSON.parse(content);
+    const updated = {
+      ...manifest,
+      ...updates
+    };
+    const tempPath = `${validationPath}.tmp`;
+    await writeFile3(tempPath, JSON.stringify(updated, null, 2), "utf-8");
+    await rename2(tempPath, validationPath);
+    if (DEBUG) {
+      console.error(
+        `[build-hooks] updateBuildValidation: updated ${validationPath}`
+      );
+    }
+  } catch (error2) {
+    if (DEBUG) {
+      console.error("[build-hooks] updateBuildValidation error:", error2);
+    }
+  }
+}
+function createBuildValidateHook(context) {
+  return async (input) => {
+    if (DEBUG) {
+      console.error(
+        "[build-hooks] PostToolUse fired:",
+        JSON.stringify(input).slice(0, 200)
+      );
+    }
+    const hookInput = input;
+    const filePath = hookInput.tool_input?.file_path;
+    const content = hookInput.tool_input?.content;
+    if (DEBUG) {
+      console.error("[build-hooks] file_path:", filePath);
+      console.error("[build-hooks] isWorkflowFile:", isWorkflowFile(filePath));
+    }
+    if (!isWorkflowFile(filePath)) {
+      return {};
+    }
+    if (!content) {
+      return {
+        decision: "block",
+        reason: "Workflow validation failed: No content provided. Please write the workflow content to the file."
+      };
+    }
+    try {
+      const parsed = parseWorkflow(content);
+      await updateBuildValidation(context ?? {}, {
+        workflowValidated: true,
+        workflowPath: filePath,
+        workflowName: parsed.definition.name,
+        status: "validated"
+      });
+      console.error(`\u2713 Workflow validated: ${parsed.definition.name}`);
+      return {};
+    } catch (error2) {
+      const errorMessage = error2 instanceof Error ? error2.message : String(error2);
+      await updateBuildValidation(context ?? {}, {
+        workflowValidated: false,
+        status: "failed",
+        error: errorMessage
+      });
+      return {
+        decision: "block",
+        reason: `Workflow validation failed: ${errorMessage}
+
+Please fix the workflow file and try writing it again. Ensure the workflow has valid YAML frontmatter with 'name', 'description', and 'steps' fields.`
+      };
+    }
+  };
+}
+function createBuildStopGuardHook(context) {
+  return async (input) => {
+    if (DEBUG) {
+      console.error(
+        "[build-hooks] Stop/SubagentStop fired:",
+        JSON.stringify(input).slice(0, 200)
+      );
+    }
+    const hookInput = input;
+    if (hookInput.stop_hook_active === true) {
+      return {};
+    }
+    const validation = await readBuildValidation(context);
+    if (DEBUG) {
+      console.error("[build-hooks] validation:", JSON.stringify(validation));
+    }
+    if (!validation) {
+      return {};
+    }
+    if (!validation.workflowValidated) {
+      return {
+        decision: "block",
+        reason: "Build incomplete. The workflow file has not been validated yet. Please write the workflow to ~/.looplia/workflows/ with valid YAML frontmatter including 'name', 'description', and 'steps' fields. Do not stop until the workflow is successfully created."
+      };
+    }
+    return {};
+  };
+}
+function createBuildHooks() {
+  const context = {
+    sandboxId: process.env.LOOPLIA_SANDBOX_ID,
+    sandboxRoot: process.env.LOOPLIA_SANDBOX_ROOT
+  };
+  return {
+    Stop: [{ hooks: [createBuildStopGuardHook(context)] }],
+    SubagentStop: [{ hooks: [createBuildStopGuardHook(context)] }],
+    PostToolUse: [
+      { matcher: "Write", hooks: [createBuildValidateHook(context)] }
+    ]
+  };
+}
+var JSON_EXTENSION_REGEX = /\.json$/;
+var LOCK_TIMEOUT_MS = 3e4;
+var LOCK_RETRY_DELAY_MS2 = 200;
+async function findMostRecentSandbox2(sandboxRoot) {
+  try {
+    const entries = await readdir32(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 = join8(sandboxRoot, dir.name);
+        const dirStat = await stat3(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 = join8(sandboxDir, "validation.json");
+  try {
+    const content = await readFile5(validationPath, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return;
+  }
+}
+function resolveSandboxRoot2(context) {
+  return context?.sandboxRoot ?? join8(getLoopliaPluginPath(), "sandbox");
+}
+async function resolveSandboxDir3(context) {
+  const sandboxRoot = resolveSandboxRoot2(context);
+  if (context?.sandboxId) {
+    return join8(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 readFile5(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 writeFile4(tempPath, JSON.stringify(manifest, null, 2), "utf-8");
+  await rename3(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 = join8(sandboxDir, outputPath);
+    try {
+      await stat3(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 resolveSandboxDir3(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 = join8(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 +25322,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();
@@ -23762,7 +25421,11 @@ When processing --file arguments or user file paths, resolve them against the Us
           "AskUserQuestion"
           // Only in interactive mode
         ],
-        outputFormat: { type: "json_schema", schema: jsonSchema }
+        // v0.7.5: Pass hooks from config if provided (build validation)
+        ...resolvedConfig?.runHooks && { hooks: resolvedConfig.runHooks },
+        ...resolvedConfig?.buildHooks && { hooks: resolvedConfig.buildHooks }
+        // 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 +25449,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 ?? join9(workspace, "sandbox")
+      });
+    }
     return finalResult ?? {
       success: false,
       error: { type: "unknown", message: "No result received" }
@@ -24018,109 +25687,12 @@ export {
   copyPlugins,
   downloadRemotePlugins,
   isLoopliaInitialized,
-  util,
-  objectUtil,
-  ZodParsedType,
-  getParsedType,
-  ZodIssueCode,
-  quotelessJson,
-  ZodError,
-  en_default,
-  setErrorMap,
-  getErrorMap,
-  makeIssue,
-  EMPTY_PATH,
-  addIssueToContext,
-  ParseStatus,
-  INVALID,
-  DIRTY,
-  OK,
-  isAborted,
-  isDirty,
-  isValid,
-  isAsync,
-  ZodType,
-  datetimeRegex,
-  ZodString,
-  ZodNumber,
-  ZodBigInt,
-  ZodBoolean,
-  ZodDate,
-  ZodSymbol,
-  ZodUndefined,
-  ZodNull,
-  ZodAny,
-  ZodUnknown,
-  ZodNever,
-  ZodVoid,
-  ZodArray,
-  ZodObject,
-  ZodUnion,
-  ZodDiscriminatedUnion,
-  ZodIntersection,
-  ZodTuple,
-  ZodRecord,
-  ZodMap,
-  ZodSet,
-  ZodFunction,
-  ZodLazy,
-  ZodLiteral,
-  ZodEnum,
-  ZodNativeEnum,
-  ZodPromise,
-  ZodEffects,
-  ZodOptional,
-  ZodNullable,
-  ZodDefault,
-  ZodCatch,
-  ZodNaN,
-  BRAND,
-  ZodBranded,
-  ZodPipeline,
-  ZodReadonly,
-  custom,
-  late,
-  ZodFirstPartyTypeKind,
-  instanceOfType,
-  stringType,
-  numberType,
-  nanType,
-  bigIntType,
-  booleanType,
-  dateType,
-  symbolType,
-  undefinedType,
-  nullType,
-  anyType,
-  unknownType,
-  neverType,
-  voidType,
-  arrayType,
-  objectType,
-  strictObjectType,
-  unionType,
-  discriminatedUnionType,
-  intersectionType,
-  tupleType,
-  recordType,
-  mapType,
-  setType,
-  functionType,
-  lazyType,
-  literalType,
-  enumType,
-  nativeEnumType,
-  promiseType,
-  effectsType,
-  optionalType,
-  nullableType,
-  preprocessType,
-  pipelineType,
-  ostring,
-  onumber,
-  oboolean,
-  coerce,
-  NEVER,
+  parseWorkflow,
+  generateValidationManifest,
+  getFinalStep,
+  isInputlessWorkflow,
+  extractWorkflowSkills,
+  validateUserProfile,
   findClaudeCodePath,
   isClaudeCodeInstalled,
   clearClaudeCodePathCache,
@@ -24147,6 +25719,8 @@ export {
   writeUserProfile,
   executeAgenticQueryStreaming,
   createClaudeAgentExecutor,
+  createBuildHooks,
+  createWorkflowHooks,
   SUMMARIZE_SYSTEM_PROMPT,
   buildSummarizePrompt,
   executeInteractiveQueryStreaming,