@looplia/looplia-cli 0.7.4 → 0.7.5

package/dist/{chunk-PXCY2LDE.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-KZZIM7FY.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
+// ../../node_modules/zod/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
+// ../../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
@@ -4347,7 +4354,799 @@ var coerce = {
   bigint: ((arg) => ZodBigInt.create({ ...arg, coerce: true })),
   date: ((arg) => ZodDate.create({ ...arg, coerce: true }))
 };
-var NEVER = INVALID;
+var NEVER = INVALID;
+
+// ../../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`);
+  }
+  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}
+
+## 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()
+  };
+}
+function parseArray(value) {
+  const match = value.match(ARRAY_PATTERN);
+  if (match?.[1] !== void 0) {
+    return match[1].split(",").map((s) => s.trim());
+  }
+  return null;
+}
+function stripQuotes(value) {
+  if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+    return value.slice(1, -1);
+  }
+  return value;
+}
+function parseYamlValue(value) {
+  const array2 = parseArray(value);
+  if (array2) {
+    return array2;
+  }
+  if (value === "true") {
+    return true;
+  }
+  if (value === "false") {
+    return false;
+  }
+  if (INTEGER_PATTERN.test(value)) {
+    return Number.parseInt(value, 10);
+  }
+  return stripQuotes(value);
+}
+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);
+    }
+  }
+}
+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;
+  }
+}
+function processInputProperty(state, trimmed) {
+  if (!state.currentInput) {
+    return;
+  }
+  const kv = parseKeyValue(trimmed);
+  if (!kv) {
+    return;
+  }
+  handleInputProperty(state.currentInput, kv.key, kv.value);
+}
+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();
@@ -5592,7 +6391,7 @@ var zodToJsonSchema = (schema, options) => {
   return combined;
 };
 
-// ../../packages/provider/dist/chunk-KZZIM7FY.js
+// ../../packages/provider/dist/chunk-W4MDOBYT.js
 import { join as join6 } from "path";
 
 // ../../node_modules/@anthropic-ai/claude-agent-sdk/sdk.mjs
@@ -5631,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],
@@ -17603,7 +18402,7 @@ function config(newConfig) {
   return globalConfig;
 }
 var exports_util = {};
-__export(exports_util, {
+__export2(exports_util, {
   unwrapMessage: () => unwrapMessage,
   stringifyPrimitive: () => stringifyPrimitive,
   required: () => required,
@@ -20531,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,
@@ -22130,7 +22929,7 @@ function query({
   return queryInstance;
 }
 
-// ../../packages/provider/dist/chunk-KZZIM7FY.js
+// ../../packages/provider/dist/chunk-W4MDOBYT.js
 import { appendFileSync as appendFileSync3, mkdirSync as mkdirSync3, writeFileSync } from "fs";
 import { join as join33 } from "path";
 import { access, readdir as readdir3, readFile as readFile22, stat } from "fs/promises";
@@ -22138,17 +22937,19 @@ 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 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 readdir22,
-  readFile as readFile4,
-  rename as rename2,
-  stat as stat2,
+  readdir as readdir32,
+  readFile as readFile5,
+  rename as rename3,
+  stat as stat3,
   unlink,
-  writeFile as writeFile3
+  writeFile as writeFile4
 } from "fs/promises";
-import { join as join7 } from "path";
 import { join as join8 } from "path";
+import { join as join9 } from "path";
 var LINE_SPLIT_REGEX = /\r?\n/;
 function findSdkBundledCliPath() {
   try {
@@ -22816,13 +23617,23 @@ function extractSandboxIdFromPrompt(prompt) {
 var extractContentIdFromPrompt = extractSandboxIdFromPrompt;
 var LOCK_MAX_RETRIES = 5;
 var LOCK_RETRY_DELAY_MS = 200;
-function isValidationManifest(value) {
+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));
 }
@@ -22946,19 +23757,21 @@ async function readFinalArtifact(sandboxDir, outputPath) {
     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");
+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
+    }
+  };
+}
+async function extractRunResult(manifest, sandboxDir) {
   const { allValidated, pendingSteps } = areAllStepsValidated(manifest.steps);
   if (!allValidated) {
     return validationError(
@@ -22987,6 +23800,24 @@ async function extractSandboxResult(options) {
     }
   };
 }
+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");
+  }
+  if (isBuildManifest(manifest)) {
+    return extractBuildResult(manifest, sandboxDir);
+  }
+  return extractRunResult(manifest, sandboxDir);
+}
 function expandPath(path) {
   if (path.startsWith("~/") || path === "~") {
     const home = homedir32();
@@ -23771,7 +24602,10 @@ When processing --file arguments or user file paths, resolve them against the Us
         // 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 }
+        ...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;
@@ -23945,12 +24779,194 @@ 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 readdir22(sandboxRoot, { withFileTypes: true });
+    const entries = await readdir32(sandboxRoot, { withFileTypes: true });
     const dirs = entries.filter(
       (e) => e.isDirectory() && !e.name.startsWith(".")
     );
@@ -23959,8 +24975,8 @@ async function findMostRecentSandbox2(sandboxRoot) {
     }
     const dirStats = await Promise.all(
       dirs.map(async (dir) => {
-        const dirPath = join7(sandboxRoot, dir.name);
-        const dirStat = await stat2(dirPath);
+        const dirPath = join8(sandboxRoot, dir.name);
+        const dirStat = await stat3(dirPath);
         return { path: dirPath, mtime: dirStat.mtime.getTime() };
       })
     );
@@ -23971,21 +24987,21 @@ async function findMostRecentSandbox2(sandboxRoot) {
   }
 }
 async function readValidationManifest2(sandboxDir) {
-  const validationPath = join7(sandboxDir, "validation.json");
+  const validationPath = join8(sandboxDir, "validation.json");
   try {
-    const content = await readFile4(validationPath, "utf-8");
+    const content = await readFile5(validationPath, "utf-8");
     return JSON.parse(content);
   } catch {
     return;
   }
 }
-function resolveSandboxRoot(context) {
-  return context?.sandboxRoot ?? join7(getLoopliaPluginPath(), "sandbox");
+function resolveSandboxRoot2(context) {
+  return context?.sandboxRoot ?? join8(getLoopliaPluginPath(), "sandbox");
 }
-async function resolveSandboxDir2(context) {
-  const sandboxRoot = resolveSandboxRoot(context);
+async function resolveSandboxDir3(context) {
+  const sandboxRoot = resolveSandboxRoot2(context);
   if (context?.sandboxId) {
-    return join7(sandboxRoot, context.sandboxId);
+    return join8(sandboxRoot, context.sandboxId);
   }
   return await findMostRecentSandbox2(sandboxRoot);
 }
@@ -24010,7 +25026,7 @@ function getSandboxArtifactInfo(filePath) {
 }
 async function readArtifactData(filePath, artifact) {
   try {
-    const content = await readFile4(filePath, "utf-8");
+    const content = await readFile5(filePath, "utf-8");
     return JSON.parse(content);
   } catch {
     console.error(`Validation failed for ${artifact}: Invalid JSON`);
@@ -24157,8 +25173,8 @@ async function acquireLock(lockPath, timeoutMs) {
 }
 async function writeValidationManifest(validationPath, manifest) {
   const tempPath = `${validationPath}.tmp`;
-  await writeFile3(tempPath, JSON.stringify(manifest, null, 2), "utf-8");
-  await rename2(tempPath, validationPath);
+  await writeFile4(tempPath, JSON.stringify(manifest, null, 2), "utf-8");
+  await rename3(tempPath, validationPath);
 }
 async function findMissingOutputs(sandboxDir, steps) {
   const missing = [];
@@ -24167,9 +25183,9 @@ async function findMissingOutputs(sandboxDir, steps) {
     if (!outputPath) {
       continue;
     }
-    const fullPath = join7(sandboxDir, outputPath);
+    const fullPath = join8(sandboxDir, outputPath);
     try {
-      await stat2(fullPath);
+      await stat3(fullPath);
     } catch {
       missing.push(stepId);
     }
@@ -24185,7 +25201,7 @@ function createStopGuardHook(context) {
     if (hookInput.stop_hook_active === true) {
       return {};
     }
-    const sandboxDir = await resolveSandboxDir2(context);
+    const sandboxDir = await resolveSandboxDir3(context);
     if (!sandboxDir) {
       return {};
     }
@@ -24228,7 +25244,7 @@ function createPostWriteValidateHook() {
     if (!artifactData) {
       return {};
     }
-    const validationPath = join7(artifactInfo.sandboxDir, "validation.json");
+    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");
@@ -24404,7 +25420,10 @@ When processing --file arguments or user file paths, resolve them against the Us
           "WebFetch",
           "AskUserQuestion"
           // Only in interactive mode
-        ]
+        ],
+        // 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()
       }
@@ -24433,7 +25452,7 @@ When processing --file arguments or user file paths, resolve them against the Us
     if (!finalResult) {
       finalResult = await extractSandboxResult({
         sandboxId: process.env.LOOPLIA_SANDBOX_ID,
-        sandboxRoot: process.env.LOOPLIA_SANDBOX_ROOT ?? join8(workspace, "sandbox")
+        sandboxRoot: process.env.LOOPLIA_SANDBOX_ROOT ?? join9(workspace, "sandbox")
       });
     }
     return finalResult ?? {
@@ -24668,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,
@@ -24797,6 +25719,7 @@ export {
   writeUserProfile,
   executeAgenticQueryStreaming,
   createClaudeAgentExecutor,
+  createBuildHooks,
   createWorkflowHooks,
   SUMMARIZE_SYSTEM_PROMPT,
   buildSummarizePrompt,