storybook-addon-designbook 0.2.0 → 0.4.0

package/dist/cli.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import * as actualFS from 'fs';
-import { readFileSync, existsSync, readdirSync, mkdirSync, appendFileSync, renameSync, writeFileSync, unlinkSync, openSync, closeSync, statSync, realpathSync as realpathSync$1, readlinkSync, readdir as readdir$1, lstatSync } from 'fs';
+import { readFileSync, existsSync, readdirSync, mkdirSync, appendFileSync, renameSync, writeFileSync, statSync, unlinkSync, openSync, closeSync, realpathSync as realpathSync$1, readlinkSync, readdir as readdir$1, lstatSync } from 'fs';
 import { load, dump } from 'js-yaml';
-import { resolve, dirname, basename, join, parse, relative, extname as extname$1, win32, posix } from 'path';
+import { resolve, dirname, basename, join, parse, extname as extname$1, delimiter, relative, win32, posix } from 'path';
 import jsonata9 from 'jsonata';
 import { EventEmitter } from 'events';
 import Stream from 'stream';
@@ -11,7 +11,7 @@ import { fileURLToPath } from 'url';
 import { realpath, readlink, readdir, lstat, readFile, mkdir, writeFile } from 'fs/promises';
 import { unescape, escape, Minimatch, GLOBSTAR } from 'minimatch';
 import { homedir } from 'os';
-import { execFileSync, spawn, execSync } from 'child_process';
+import { spawn, execSync } from 'child_process';
 import * as http from 'http';
 import { createHash, randomBytes } from 'crypto';
 import { Command } from 'commander';
@@ -2366,10 +2366,10 @@ var init_esm2 = __esm({
        * Return a void Promise that resolves once the stream ends.
        */
       async promise() {
-        return new Promise((resolve19, reject) => {
+        return new Promise((resolve20, reject) => {
           this.on(DESTROYED, () => reject(new Error("stream destroyed")));
           this.on("error", (er) => reject(er));
-          this.on("end", () => resolve19());
+          this.on("end", () => resolve20());
         });
       }
       /**
@@ -2393,7 +2393,7 @@ var init_esm2 = __esm({
             return Promise.resolve({ done: false, value: res });
           if (this[EOF])
             return stop();
-          let resolve19;
+          let resolve20;
           let reject;
           const onerr = (er) => {
             this.off("data", ondata);
@@ -2407,19 +2407,19 @@ var init_esm2 = __esm({
             this.off("end", onend);
             this.off(DESTROYED, ondestroy);
             this.pause();
-            resolve19({ value, done: !!this[EOF] });
+            resolve20({ value, done: !!this[EOF] });
           };
           const onend = () => {
             this.off("error", onerr);
             this.off("data", ondata);
             this.off(DESTROYED, ondestroy);
             stop();
-            resolve19({ done: true, value: void 0 });
+            resolve20({ done: true, value: void 0 });
           };
           const ondestroy = () => onerr(new Error("stream destroyed"));
           return new Promise((res2, rej) => {
             reject = rej;
-            resolve19 = res2;
+            resolve20 = res2;
             this.once(DESTROYED, ondestroy);
             this.once("error", onerr);
             this.once("end", onend);
@@ -3288,7 +3288,7 @@ var init_esm3 = __esm({
         }
       }
       #applyStat(st) {
-        const { atime, atimeMs, birthtime, birthtimeMs, blksize, blocks, ctime, ctimeMs, dev, gid, ino, mode, mtime, mtimeMs, nlink, rdev, size, uid } = st;
+        const { atime, atimeMs, birthtime, birthtimeMs, blksize, blocks, ctime, ctimeMs, dev, gid, ino, mode, mtime, mtimeMs: mtimeMs2, nlink, rdev, size, uid } = st;
         this.#atime = atime;
         this.#atimeMs = atimeMs;
         this.#birthtime = birthtime;
@@ -3302,7 +3302,7 @@ var init_esm3 = __esm({
         this.#ino = ino;
         this.#mode = mode;
         this.#mtime = mtime;
-        this.#mtimeMs = mtimeMs;
+        this.#mtimeMs = mtimeMs2;
         this.#nlink = nlink;
         this.#rdev = rdev;
         this.#size = size;
@@ -3396,9 +3396,9 @@ var init_esm3 = __esm({
         if (this.#asyncReaddirInFlight) {
           await this.#asyncReaddirInFlight;
         } else {
-          let resolve19 = () => {
+          let resolve20 = () => {
           };
-          this.#asyncReaddirInFlight = new Promise((res) => resolve19 = res);
+          this.#asyncReaddirInFlight = new Promise((res) => resolve20 = res);
           try {
             for (const e of await this.#fs.promises.readdir(fullpath, {
               withFileTypes: true
@@ -3411,7 +3411,7 @@ var init_esm3 = __esm({
             children.provisional = 0;
           }
           this.#asyncReaddirInFlight = void 0;
-          resolve19();
+          resolve20();
         }
         return children.slice(0, children.provisional);
       }
@@ -4480,10 +4480,10 @@ var init_ignore = __esm({
       ignored(p) {
         const fullpath = p.fullpath();
         const fullpaths = `${fullpath}/`;
-        const relative4 = p.relative() || ".";
-        const relatives = `${relative4}/`;
+        const relative3 = p.relative() || ".";
+        const relatives = `${relative3}/`;
         for (const m of this.relative) {
-          if (m.match(relative4) || m.match(relatives))
+          if (m.match(relative3) || m.match(relatives))
             return true;
         }
         for (const m of this.absolute) {
@@ -4494,9 +4494,9 @@ var init_ignore = __esm({
       }
       childrenIgnored(p) {
         const fullpath = p.fullpath() + "/";
-        const relative4 = (p.relative() || ".") + "/";
+        const relative3 = (p.relative() || ".") + "/";
         for (const m of this.relativeChildren) {
-          if (m.match(relative4))
+          if (m.match(relative3))
             return true;
         }
         for (const m of this.absoluteChildren) {
@@ -5345,21 +5345,21 @@ var init_esm4 = __esm({
   }
 });
 function findFreePort() {
-  return new Promise((resolve19, reject) => {
+  return new Promise((resolve20, reject) => {
     const server = http.createServer();
     server.listen(0, "127.0.0.1", () => {
       const addr = server.address();
       const port = typeof addr === "object" && addr ? addr.port : null;
       server.close((err) => {
         if (err || port === null) reject(err ?? new Error("Could not determine port"));
-        else resolve19(port);
+        else resolve20(port);
       });
     });
     server.on("error", reject);
   });
 }
 function fetchJson(url2) {
-  return new Promise((resolve19, reject) => {
+  return new Promise((resolve20, reject) => {
     http.get(url2, (res) => {
       if (res.statusCode !== 200) {
         res.resume();
@@ -5372,7 +5372,7 @@ function fetchJson(url2) {
       });
       res.on("end", () => {
         try {
-          resolve19(JSON.parse(body));
+          resolve20(JSON.parse(body));
         } catch {
           reject(new Error("Invalid JSON"));
         }
@@ -6308,6 +6308,15 @@ function toKebab(input) {
 }
 function normaliseToSectionId(input) {
   const [withoutVariant = input] = input.split("--");
+  if (!withoutVariant.includes("/")) {
+    if (DESIGN_SYSTEM_STORY_ID.test(withoutVariant)) {
+      return { id: "shell" };
+    }
+    const storyMatch = SECTION_STORY_ID.exec(withoutVariant);
+    if (storyMatch?.[1]) {
+      return { id: storyMatch[1] };
+    }
+  }
   const segments = withoutVariant.split("/").map((s) => s.trim()).filter(Boolean);
   if (segments.length === 0) {
     return null;
@@ -6327,9 +6336,11 @@ function normaliseToSectionId(input) {
   const id = toKebab(first);
   return id ? { id } : null;
 }
-var scenePathResolver;
+var SECTION_STORY_ID, DESIGN_SYSTEM_STORY_ID, scenePathResolver;
 var init_scene_path = __esm({
   "src/resolvers/scene-path.ts"() {
+    SECTION_STORY_ID = /^designbook-sections-(.+?)-scenes$/;
+    DESIGN_SYSTEM_STORY_ID = /^designbook-design-system-scenes$/;
     scenePathResolver = {
       name: "scene_path",
       resolve(input, _config, _context) {
@@ -6391,6 +6402,9 @@ var init_components_index = __esm({
     init_story_patterns();
     componentsIndexResolver = {
       name: "components_index",
+      // Producer: derives the inventory from the live Storybook index, with no
+      // input param. Must run even though nothing supplies `components`.
+      requiresInput: false,
       async resolve(_input, _config, context2) {
         const config = context2.config;
         const framework = String(config["frameworks.component"] ?? "");
@@ -6946,8 +6960,8 @@ function pickRegionLabel(params) {
     if (segments[0] === "design-system") {
       return "shell";
     }
-    const basename4 = segments[segments.length - 1] ?? "";
-    return basename4.replace(/(\.[^./]+)+$/, "");
+    const basename5 = segments[segments.length - 1] ?? "";
+    return basename5.replace(/(\.[^./]+)+$/, "");
   }
   return "";
 }
@@ -7166,7 +7180,7 @@ async function resolveParams(schema, context2) {
       return;
     }
     const input = outputParams[key];
-    if (input === void 0 && !decl.from) return;
+    if (input === void 0 && !decl.from && resolver.requiresInput !== false) return;
     let effectiveInput;
     if (decl.from) {
       let fromValue;
@@ -8269,6 +8283,9 @@ __export(validation_registry_exports, {
   getValidatorKeys: () => getValidatorKeys,
   validateByKeys: () => validateByKeys
 });
+function shellQuote(value) {
+  return `'${value.replace(/'/g, `'\\''`)}'`;
+}
 function toFileResult(result, file, type) {
   const ts = (/* @__PURE__ */ new Date()).toISOString();
   return {
@@ -8296,7 +8313,7 @@ async function validateByKeys(keys, file, config) {
   for (const key of keys) {
     if (key.startsWith("cmd:")) {
       const cmdTemplate = key.slice(4);
-      const cmd = cmdTemplate.replace(/\{\{\s*file\s*\}\}/g, file);
+      const cmd = cmdTemplate.replace(/\{\{\s*file\s*\}\}/g, shellQuote(file));
       const ts = (/* @__PURE__ */ new Date()).toISOString();
       try {
         execSync(cmd, { timeout: 3e4, stdio: ["pipe", "pipe", "pipe"] });
@@ -8346,11 +8363,11 @@ var init_validation_registry = __esm({
         const buildResult = await validateSceneBuild2(file, config);
         if (!buildResult.valid) return buildResult;
         const { load: parseYaml16 } = await import('js-yaml');
-        const { readFileSync: readFileSync24, existsSync: existsSync26 } = await import('fs');
-        if (!existsSync26(file)) return buildResult;
+        const { readFileSync: readFileSync23, existsSync: existsSync25 } = await import('fs');
+        if (!existsSync25(file)) return buildResult;
         let raw;
         try {
-          raw = parseYaml16(readFileSync24(file, "utf-8"));
+          raw = parseYaml16(readFileSync23(file, "utf-8"));
         } catch {
           return buildResult;
         }
@@ -8688,6 +8705,11 @@ function resolveSkillsRoot(configDir) {
   }
   return resolve(configDir, ".claude");
 }
+function expandTilde(p) {
+  if (p === "~") return homedir();
+  if (p.startsWith("~/") || p.startsWith("~\\")) return resolve(homedir(), p.slice(2));
+  return p;
+}
 function assertNotRepoRoot(dataDir) {
   const parent = dirname(dataDir);
   const hasPnpmWorkspace = existsSync(resolve(parent, "pnpm-workspace.yaml"));
@@ -8752,6 +8774,9 @@ function loadConfig(startDir) {
         config[key] = resolve(configDir, config[key]);
       }
     }
+    if (typeof config["skills"] === "string") {
+      config["skills"] = resolve(configDir, expandTilde(config["skills"]));
+    }
     return config;
   } catch (err) {
     throw new Error(`Failed to parse designbook.config.yml: ${err.message}`);
@@ -8761,6 +8786,165 @@ function loadConfig(startDir) {
 // src/cli.ts
 init_data();
 init_entity_mapping();
+var ARTIFACT_SUBDIRS = ["workflows", "tasks", "rules", "blueprints"];
+function isSkillContentRoot(dir) {
+  if (!existsSync(dir)) return false;
+  for (const sub of ARTIFACT_SUBDIRS) {
+    if (existsSync(resolve(dir, sub))) return true;
+  }
+  let children;
+  try {
+    children = readdirSync(dir);
+  } catch {
+    return false;
+  }
+  for (const child of children) {
+    const childDir = resolve(dir, child);
+    if (!isDir(childDir)) continue;
+    for (const sub of ARTIFACT_SUBDIRS) {
+      if (existsSync(resolve(childDir, sub))) return true;
+    }
+  }
+  return false;
+}
+function isDir(p) {
+  try {
+    return statSync(p).isDirectory();
+  } catch {
+    return false;
+  }
+}
+function mtimeMs(p) {
+  try {
+    return statSync(p).mtimeMs;
+  } catch {
+    return 0;
+  }
+}
+function listDirs(dir) {
+  try {
+    return readdirSync(dir).filter((c) => isDir(resolve(dir, c)));
+  } catch {
+    return [];
+  }
+}
+function deriveSkillSourcesFromBase(base) {
+  const B = resolve(base);
+  if (!existsSync(B)) return [];
+  const sources = [];
+  for (const skillName of listDirs(B)) {
+    const skillDir = resolve(B, skillName);
+    const hashRoots = listDirs(skillDir).map((h) => resolve(skillDir, h)).filter(isSkillContentRoot);
+    if (hashRoots.length > 0) {
+      const best = hashRoots.reduce((a, b) => mtimeMs(b) > mtimeMs(a) ? b : a);
+      sources.push({ name: skillName, root: best, origin: "plugin" });
+      continue;
+    }
+    if (isSkillContentRoot(skillDir)) {
+      sources.push({ name: skillName, root: skillDir, origin: "plugin" });
+    }
+  }
+  if (sources.length > 0) return sources;
+  if (isSkillContentRoot(B)) return [{ name: basename(B), root: B, origin: "plugin" }];
+  return [];
+}
+function resolveProjectSkillSources(configDir) {
+  const skillsRoot = resolveSkillsRoot(configDir);
+  const skillsDir = resolve(skillsRoot, "skills");
+  if (!existsSync(skillsDir)) return [];
+  const sources = [];
+  for (const child of listDirs(skillsDir)) {
+    sources.push({ name: child, root: resolve(skillsDir, child), origin: "project" });
+  }
+  return sources;
+}
+
+// src/skill-resolver.ts
+function pathScanBase(env) {
+  const raw = env["PATH"] ?? "";
+  for (const entry of raw.split(delimiter)) {
+    if (!entry) continue;
+    const cleaned = entry.replace(/[\\/]+$/, "");
+    if (!/[\\/]plugins[\\/]cache[\\/][^\\/]+[\\/]designbook(?:-[^\\/]+)?[\\/][^\\/]+[\\/]bin$/.test(cleaned)) {
+      continue;
+    }
+    const contentRoot = dirname(cleaned);
+    const skillDir = dirname(contentRoot);
+    return dirname(skillDir);
+  }
+  return null;
+}
+function firstNonEmpty(bases) {
+  for (const base of bases) {
+    if (!base) continue;
+    const sources = deriveSkillSourcesFromBase(base);
+    if (sources.length > 0) return sources;
+  }
+  return [];
+}
+var configResolver = {
+  name: "config",
+  apply: (ctx) => typeof ctx.config.skills === "string" && ctx.config.skills ? firstNonEmpty([ctx.config.skills]) : []
+};
+var claudeCodeResolver = {
+  name: "claude-code",
+  apply: (ctx) => {
+    const isClaudeCode = ctx.env["CLAUDECODE"] === "1" || /claude-code/.test(ctx.env["AI_AGENT"] ?? "");
+    if (!isClaudeCode) return [];
+    return firstNonEmpty([pathScanBase(ctx.env), join(ctx.home, ".claude", "plugins", "cache", "designbook")]);
+  }
+};
+var codexResolver = {
+  name: "codex",
+  apply: (ctx) => {
+    const codexHome = ctx.env["CODEX_HOME"] ? ctx.env["CODEX_HOME"] : join(ctx.home, ".codex");
+    return firstNonEmpty([join(codexHome, "skills")]);
+  }
+};
+var geminiResolver = {
+  name: "gemini",
+  apply: (ctx) => firstNonEmpty([join(ctx.home, ".gemini", "skills")])
+};
+var agentsResolver = {
+  name: "agents",
+  apply: (ctx) => firstNonEmpty([join(ctx.home, ".agents", "skills")])
+};
+var BUILT_IN_RESOLVERS = [
+  configResolver,
+  claudeCodeResolver,
+  codexResolver,
+  geminiResolver,
+  agentsResolver
+];
+function resolvePluginSkillSources(ctx) {
+  const runtimeDisabled = ctx.env["DESIGNBOOK_DISABLE_AUTODETECT"] === "1";
+  for (const resolver of BUILT_IN_RESOLVERS) {
+    if (runtimeDisabled && resolver.name !== "config") continue;
+    const sources = resolver.apply(ctx);
+    if (sources.length > 0) return { runtime: resolver.name, sources };
+  }
+  return null;
+}
+function resolveSkillSources(configDir, overrides) {
+  const ctx = {
+    env: process.env,
+    home: homedir(),
+    config: loadConfig(configDir)
+  };
+  const projectSources = resolveProjectSkillSources(configDir);
+  const pluginResult = resolvePluginSkillSources(ctx);
+  if (pluginResult && process.env["DESIGNBOOK_DEBUG"]) {
+    const base = pluginResult.sources[0]?.root ?? "?";
+    process.stderr.write(`[designbook] skills: ${pluginResult.runtime} \u2192 ${base}
+`);
+  }
+  const byName = /* @__PURE__ */ new Map();
+  for (const src of projectSources) byName.set(src.name, src);
+  for (const src of pluginResult?.sources ?? []) {
+    if (!byName.has(src.name)) byName.set(src.name, src);
+  }
+  return Array.from(byName.values());
+}
 var LONG_RUNNING_MS = 1e4;
 function digestLog(logPath2) {
   if (!existsSync(logPath2)) {
@@ -8831,50 +9015,125 @@ function evalAssertions(assertions, output) {
   }
   return { passed, total, failures };
 }
-var MAX_RETRIES = 10;
-var STALE_LOCK_MS = 3e4;
-function acquireLock(filePath) {
-  const lockPath = `${filePath}.lock`;
-  for (let attempt = 0; attempt < MAX_RETRIES; attempt++) {
-    if (existsSync(lockPath)) {
+function deboSuffix(data) {
+  if (!data.workflow_id) throw new Error("workflow_id is required for direct engine stash-at-target");
+  return `.${data.workflow_id}.debo`;
+}
+function stashPath(data, fileEntry) {
+  return fileEntry.path + deboSuffix(data);
+}
+var directEngine = {
+  writeFile(data, task, key, content) {
+    const fileEntry = (task.files ?? []).find((f) => f.key === key);
+    if (!fileEntry) throw new Error(`No file entry with key '${key}' in task '${task.id}'`);
+    const path = stashPath(data, fileEntry);
+    mkdirSync(dirname(path), { recursive: true });
+    writeFileSync(path, content);
+    return { path };
+  },
+  getStagedPath(data, task, key) {
+    const fileEntry = (task.files ?? []).find((f) => f.key === key);
+    if (fileEntry) return stashPath(data, fileEntry);
+    const resultEntry = task.result?.[key];
+    if (resultEntry?.path) {
+      return resultEntry.path;
+    }
+    throw new Error(`No file entry with key '${key}' in task '${task.id}'`);
+  },
+  flush(data, tasks) {
+    const suffix = deboSuffix(data);
+    const now = (/* @__PURE__ */ new Date()).toISOString();
+    for (const task of tasks) {
+      for (const file of task.files ?? []) {
+        if (!file.validation_result) continue;
+        const src = file.path + suffix;
+        if (!existsSync(src)) continue;
+        mkdirSync(dirname(file.path), { recursive: true });
+        renameSync(src, file.path);
+        file.flushed_at = now;
+      }
+    }
+    return Promise.resolve();
+  },
+  done() {
+    return { archive: true };
+  },
+  cleanup(data) {
+    const suffix = deboSuffix(data);
+    const dirs = /* @__PURE__ */ new Set();
+    for (const task of data.tasks) {
+      for (const file of task.files ?? []) {
+        dirs.add(dirname(file.path));
+      }
+    }
+    for (const dir of dirs) {
+      if (!existsSync(dir)) continue;
       try {
-        const content = readFileSync(lockPath, "utf-8");
-        const lockTime = parseInt(content, 10);
-        if (Date.now() - lockTime > STALE_LOCK_MS) {
-          try {
-            unlinkSync(lockPath);
-          } catch {
+        const entries = readdirSync(dir);
+        for (const entry of entries) {
+          if (entry.endsWith(suffix)) {
+            unlinkSync(resolve(dir, entry));
           }
         }
       } catch {
       }
     }
-    try {
-      writeFileSync(lockPath, String(Date.now()), { flag: "wx" });
-      return lockPath;
-    } catch (err) {
-      if (err.code !== "EEXIST") {
-        throw err;
+  },
+  async onTransition(from, to, ctx) {
+    const declared = ctx.data.stages ? Object.keys(ctx.data.stages) : [];
+    if (declared.includes(from)) {
+      const stageTasks = ctx.data.tasks.filter((t) => t.stage === from);
+      if (stageTasks.length > 0) {
+        await directEngine.flush(ctx.data, stageTasks);
       }
     }
+    if (from === "finalizing" && to === "done") {
+      return { archive: true };
+    }
+    return {};
   }
-  throw new Error(
-    `Failed to acquire lock on ${filePath} after ${MAX_RETRIES} attempts. Another process may be writing to this file.`
-  );
+};
+
+// src/engines/index.ts
+var engines = {
+  direct: directEngine
+};
+
+// src/workflow-lifecycle.ts
+var IMPLICIT_STAGES = {
+  _after_declared: ["committed"],
+  _before_done: ["finalizing", "done"]
+};
+function buildLifecycleOrder(stages) {
+  const declared = Object.keys(stages).filter((s) => (stages[s].steps?.length ?? 0) > 0);
+  return ["created", "planned", ...declared, ...IMPLICIT_STAGES._after_declared, ...IMPLICIT_STAGES._before_done];
 }
-function releaseLock(lockPath) {
-  try {
-    unlinkSync(lockPath);
-  } catch {
-  }
+function getNextStage(current, stages) {
+  const order = buildLifecycleOrder(stages);
+  const currentIdx = order.indexOf(current);
+  if (currentIdx === -1 || currentIdx >= order.length - 1) return null;
+  return order[currentIdx + 1] ?? null;
 }
-async function withLockAsync(filePath, fn) {
-  const lockPath = acquireLock(filePath);
-  try {
-    return await fn();
-  } finally {
-    releaseLock(lockPath);
+function getNextStep(currentStage, _completedStep, tasks) {
+  const pending = tasks.find((t) => t.stage === currentStage && t.status !== "done");
+  return pending?.step ?? null;
+}
+function checkStageParams(stage, stages, provided) {
+  const def = stages[stage];
+  if (!def?.params) return null;
+  const unfulfilled = {};
+  for (const [key, param] of Object.entries(def.params)) {
+    if (provided[key] === void 0) {
+      unfulfilled[key] = param;
+    }
   }
+  return Object.keys(unfulfilled).length > 0 ? unfulfilled : null;
+}
+function interpolatePrompt(prompt, state) {
+  return prompt.replace(/\{(\w+)\}/g, (_match, key) => {
+    const value = state[key];
+    return value !== void 0 ? String(value) : `{${key}}`;
+  });
 }
 
 // src/workflow-resolve.ts
@@ -8970,7 +9229,7 @@ function pullType(ref2, baseFilePath, baseFileSchemas, definitions, input, visit
     srcFile = baseFilePath;
     srcSchemas = baseFileSchemas;
   } else {
-    const r = resolveSchemaRef(ref2, baseFilePath, input.skillsRoot);
+    const r = resolveSchemaRef(ref2, baseFilePath, input.skillsRoot, input.sources);
     typeName = r.typeName;
     schema = r.schema;
     srcFile = r.schemaFilePath;
@@ -9084,10 +9343,10 @@ function parseSchemaExtension(filePath) {
   }
   return hasAny ? ext : null;
 }
-function resolveRefsInExtension(obj, sourceFilePath, skillsRoot, schemas) {
+function resolveRefsInExtension(obj, sourceFilePath, skillsRoot, schemas, sources) {
   for (const [key, value] of Object.entries(obj)) {
     if (key === "$ref" && typeof value === "string") {
-      const { typeName, schema } = resolveSchemaRef(value, sourceFilePath, skillsRoot);
+      const { typeName, schema } = resolveSchemaRef(value, sourceFilePath, skillsRoot, sources);
       schemas[typeName] = schema;
       delete obj.$ref;
       Object.assign(obj, schema);
@@ -9096,11 +9355,11 @@ function resolveRefsInExtension(obj, sourceFilePath, skillsRoot, schemas) {
     if (Array.isArray(value)) {
       for (const item of value) {
         if (item && typeof item === "object") {
-          resolveRefsInExtension(item, sourceFilePath, skillsRoot, schemas);
+          resolveRefsInExtension(item, sourceFilePath, skillsRoot, schemas, sources);
         }
       }
     } else if (value && typeof value === "object") {
-      resolveRefsInExtension(value, sourceFilePath, skillsRoot, schemas);
+      resolveRefsInExtension(value, sourceFilePath, skillsRoot, schemas, sources);
     }
   }
 }
@@ -9184,9 +9443,9 @@ function computeMergedSchema(baseResult, input) {
       if (ext.constrains) {
         throw new Error(`Blueprint '${bp2}' uses constrains: \u2014 only rules may constrain schemas`);
       }
-      if (ext.extends) resolveRefsInExtension(ext.extends, bp2, input.skillsRoot, input.schemas);
+      if (ext.extends) resolveRefsInExtension(ext.extends, bp2, input.skillsRoot, input.schemas, input.sources);
       if (ext.provides && typeof ext.provides === "object") {
-        resolveRefsInExtension(ext.provides, bp2, input.skillsRoot, input.schemas);
+        resolveRefsInExtension(ext.provides, bp2, input.skillsRoot, input.schemas, input.sources);
       }
       blueprintExts.push({ path: bp2, ext });
     }
@@ -9197,11 +9456,17 @@ function computeMergedSchema(baseResult, input) {
       if (typeof ext.provides === "string") {
         ext.provides = void 0;
       }
-      if (ext.extends) resolveRefsInExtension(ext.extends, rule, input.skillsRoot, input.schemas);
+      if (ext.extends) resolveRefsInExtension(ext.extends, rule, input.skillsRoot, input.schemas, input.sources);
       if (ext.provides && typeof ext.provides === "object") {
-        resolveRefsInExtension(ext.provides, rule, input.skillsRoot, input.schemas);
+        resolveRefsInExtension(
+          ext.provides,
+          rule,
+          input.skillsRoot,
+          input.schemas,
+          input.sources
+        );
       }
-      if (ext.constrains) resolveRefsInExtension(ext.constrains, rule, input.skillsRoot, input.schemas);
+      if (ext.constrains) resolveRefsInExtension(ext.constrains, rule, input.skillsRoot, input.schemas, input.sources);
       ruleExts.push({ path: rule, ext });
     }
   }
@@ -9270,6 +9535,22 @@ function computeMergedSchema(baseResult, input) {
 }
 
 // src/workflow-resolve.ts
+function pluginSources(sources) {
+  return (sources ?? []).filter((s) => s.origin === "plugin");
+}
+function toSourcePattern(globPattern) {
+  return globPattern.replace(/^skills\/\*\*\//, "**/");
+}
+function derivePluginArtifactName(source2, filePath) {
+  const rel = relative(source2.root, filePath).replace(/\\/g, "/");
+  const parts = rel.split("/");
+  const artifact = (parts[parts.length - 1] ?? "").replace(/\.md$/, "");
+  if (parts.length >= 3) {
+    const concern = parts[0];
+    return `${source2.name}:${concern}:${artifact}`;
+  }
+  return `${source2.name}:${artifact}`;
+}
 function loadSchemaFile(schemaFilePath) {
   if (!existsSync(schemaFilePath)) {
     throw new Error(`Schema file not found: ${schemaFilePath}`);
@@ -9291,7 +9572,21 @@ function loadSchemaFile(schemaFilePath) {
   }
   return schemas;
 }
-function resolveSchemaRef(ref2, taskFilePath, skillsRoot) {
+function reanchorRelativeRefToPluginSource(resolvedPath, sources) {
+  const plugins = pluginSources(sources);
+  if (plugins.length === 0) return void 0;
+  const byName = new Map(plugins.map((s) => [s.name, s]));
+  const segments = resolvedPath.replace(/\\/g, "/").split("/");
+  for (let i = segments.length - 2; i >= 0; i--) {
+    const source2 = byName.get(segments[i]);
+    if (!source2) continue;
+    const rest = segments.slice(i + 1).join("/");
+    const candidate = resolve(source2.root, rest);
+    if (existsSync(candidate)) return candidate;
+  }
+  return void 0;
+}
+function resolveSchemaRef(ref2, taskFilePath, skillsRoot, sources) {
   const hashIdx = ref2.indexOf("#/");
   if (hashIdx === -1) {
     throw new Error(`Invalid $ref '${ref2}' \u2014 must contain '#/' fragment (e.g. ../schemas.yml#/TypeName)`);
@@ -9301,8 +9596,19 @@ function resolveSchemaRef(ref2, taskFilePath, skillsRoot) {
   let schemaFilePath;
   if (filePart.startsWith(".") || filePart.startsWith("/")) {
     schemaFilePath = resolve(dirname(taskFilePath), filePart);
+    if (!existsSync(schemaFilePath)) {
+      const reanchored = reanchorRelativeRefToPluginSource(schemaFilePath, sources);
+      if (reanchored) schemaFilePath = reanchored;
+    }
   } else {
-    schemaFilePath = resolve(skillsRoot, filePart);
+    const skillName = filePart.split("/")[0] ?? "";
+    const pluginSource = pluginSources(sources).find((s) => s.name === skillName);
+    if (pluginSource) {
+      const rest = filePart.slice(skillName.length + 1);
+      schemaFilePath = resolve(pluginSource.root, rest);
+    } else {
+      schemaFilePath = resolve(skillsRoot, filePart);
+    }
   }
   const fileSchemas = loadSchemaFile(schemaFilePath);
   if (!(typeName in fileSchemas)) {
@@ -9311,10 +9617,10 @@ function resolveSchemaRef(ref2, taskFilePath, skillsRoot) {
   }
   return { typeName, schema: fileSchemas[typeName], schemaFilePath, fileSchemas };
 }
-function collectLocalRefsFromSchema(node, fileSchemas, schemas, visited, schemaFilePath, skillsRoot) {
+function collectLocalRefsFromSchema(node, fileSchemas, schemas, visited, schemaFilePath, skillsRoot, sources) {
   if (Array.isArray(node)) {
     for (const item of node)
-      collectLocalRefsFromSchema(item, fileSchemas, schemas, visited, schemaFilePath, skillsRoot);
+      collectLocalRefsFromSchema(item, fileSchemas, schemas, visited, schemaFilePath, skillsRoot, sources);
     return;
   }
   if (!node || typeof node !== "object") return;
@@ -9326,10 +9632,18 @@ function collectLocalRefsFromSchema(node, fileSchemas, schemas, visited, schemaF
       if (typeName && !(typeName in schemas) && typeName in fileSchemas && !visited.has(typeName)) {
         visited.add(typeName);
         schemas[typeName] = fileSchemas[typeName];
-        collectLocalRefsFromSchema(fileSchemas[typeName], fileSchemas, schemas, visited, schemaFilePath, skillsRoot);
+        collectLocalRefsFromSchema(
+          fileSchemas[typeName],
+          fileSchemas,
+          schemas,
+          visited,
+          schemaFilePath,
+          skillsRoot,
+          sources
+        );
       }
     } else if (ref2.includes("#/")) {
-      const resolved = resolveSchemaRef(ref2, schemaFilePath, skillsRoot);
+      const resolved = resolveSchemaRef(ref2, schemaFilePath, skillsRoot, sources);
       obj.$ref = `#/${resolved.typeName}`;
       if (!(resolved.typeName in schemas) && !visited.has(resolved.typeName)) {
         visited.add(resolved.typeName);
@@ -9340,16 +9654,17 @@ function collectLocalRefsFromSchema(node, fileSchemas, schemas, visited, schemaF
           schemas,
           visited,
           resolved.schemaFilePath,
-          skillsRoot
+          skillsRoot,
+          sources
         );
       }
     }
   }
   for (const value of Object.values(obj)) {
-    collectLocalRefsFromSchema(value, fileSchemas, schemas, visited, schemaFilePath, skillsRoot);
+    collectLocalRefsFromSchema(value, fileSchemas, schemas, visited, schemaFilePath, skillsRoot, sources);
   }
 }
-function resolveSchemasForTasks(tasks, skillsRoot, schemas) {
+function resolveSchemasForTasks(tasks, skillsRoot, schemas, sources) {
   for (const task of tasks) {
     if (!task.result || !task.task_file) continue;
     const taskFilePath = task.task_file;
@@ -9359,25 +9674,40 @@ function resolveSchemasForTasks(tasks, skillsRoot, schemas) {
     if (!resultProperties) continue;
     for (const [key, resultDecl] of Object.entries(resultProperties)) {
       const originalRef = resultDecl.$ref;
-      resolveRefsInDeclaration(resultDecl, taskFilePath, skillsRoot, schemas);
+      resolveRefsInDeclaration(resultDecl, taskFilePath, skillsRoot, schemas, sources);
       if (task.result[key] && originalRef) {
         const { typeName, schema, fileSchemas, schemaFilePath } = resolveSchemaRef(
           originalRef,
           taskFilePath,
-          skillsRoot
+          skillsRoot,
+          sources
         );
         schemas[typeName] = schema;
-        collectLocalRefsFromSchema(schema, fileSchemas, schemas, /* @__PURE__ */ new Set([typeName]), schemaFilePath, skillsRoot);
+        collectLocalRefsFromSchema(
+          schema,
+          fileSchemas,
+          schemas,
+          /* @__PURE__ */ new Set([typeName]),
+          schemaFilePath,
+          skillsRoot,
+          sources
+        );
         task.result[key].schema = schema;
       }
       if (task.result[key]?.schema && typeof task.result[key].schema === "object") {
-        rewriteRefsInSchema(task.result[key].schema, taskFilePath, skillsRoot, schemas);
+        rewriteRefsInSchema(
+          task.result[key].schema,
+          taskFilePath,
+          skillsRoot,
+          schemas,
+          sources
+        );
       }
     }
     if (taskFm.each) {
       for (const eachValue of Object.values(taskFm.each)) {
         if (eachValue && typeof eachValue === "object") {
-          resolveRefsInDeclaration(eachValue, taskFilePath, skillsRoot, schemas);
+          resolveRefsInDeclaration(eachValue, taskFilePath, skillsRoot, schemas, sources);
         }
       }
     }
@@ -9388,9 +9718,17 @@ function resolveSchemasForTasks(tasks, skillsRoot, schemas) {
         schema: refSchema,
         fileSchemas,
         schemaFilePath
-      } = resolveSchemaRef(ref2, taskFilePath, skillsRoot);
+      } = resolveSchemaRef(ref2, taskFilePath, skillsRoot, sources);
       schemas[typeName] = refSchema;
-      collectLocalRefsFromSchema(refSchema, fileSchemas, schemas, /* @__PURE__ */ new Set([typeName]), schemaFilePath, skillsRoot);
+      collectLocalRefsFromSchema(
+        refSchema,
+        fileSchemas,
+        schemas,
+        /* @__PURE__ */ new Set([typeName]),
+        schemaFilePath,
+        skillsRoot,
+        sources
+      );
     }
   }
   let inventory;
@@ -9415,26 +9753,31 @@ function deriveSkillsRootFromTaskFile(taskFilePath) {
   if (idx === -1) return void 0;
   return taskFilePath.slice(0, idx + marker.length - 1);
 }
-function resolveRefsInDeclaration(obj, taskFilePath, skillsRoot, schemas) {
+function resolveRefsInDeclaration(obj, taskFilePath, skillsRoot, schemas, sources) {
   if (obj.$ref && typeof obj.$ref === "string") {
-    const { typeName, schema, fileSchemas, schemaFilePath } = resolveSchemaRef(obj.$ref, taskFilePath, skillsRoot);
+    const { typeName, schema, fileSchemas, schemaFilePath } = resolveSchemaRef(
+      obj.$ref,
+      taskFilePath,
+      skillsRoot,
+      sources
+    );
     schemas[typeName] = schema;
-    collectLocalRefsFromSchema(schema, fileSchemas, schemas, /* @__PURE__ */ new Set([typeName]), schemaFilePath, skillsRoot);
+    collectLocalRefsFromSchema(schema, fileSchemas, schemas, /* @__PURE__ */ new Set([typeName]), schemaFilePath, skillsRoot, sources);
     obj.$ref = `#/${typeName}`;
   }
   for (const value of Object.values(obj)) {
     if (Array.isArray(value)) {
       for (const item of value) {
         if (item && typeof item === "object") {
-          resolveRefsInDeclaration(item, taskFilePath, skillsRoot, schemas);
+          resolveRefsInDeclaration(item, taskFilePath, skillsRoot, schemas, sources);
         }
       }
     } else if (value && typeof value === "object") {
-      resolveRefsInDeclaration(value, taskFilePath, skillsRoot, schemas);
+      resolveRefsInDeclaration(value, taskFilePath, skillsRoot, schemas, sources);
     }
   }
 }
-function rewriteRefsInSchema(obj, taskFilePath, skillsRoot, schemas) {
+function rewriteRefsInSchema(obj, taskFilePath, skillsRoot, schemas, sources) {
   if (obj.$ref && typeof obj.$ref === "string") {
     const ref2 = obj.$ref;
     if (ref2.includes("#/") && !ref2.startsWith("#/")) {
@@ -9443,9 +9786,9 @@ function rewriteRefsInSchema(obj, taskFilePath, skillsRoot, schemas) {
         schema,
         fileSchemas,
         schemaFilePath: refFilePath
-      } = resolveSchemaRef(ref2, taskFilePath, skillsRoot);
+      } = resolveSchemaRef(ref2, taskFilePath, skillsRoot, sources);
       schemas[typeName] = schema;
-      collectLocalRefsFromSchema(schema, fileSchemas, schemas, /* @__PURE__ */ new Set([typeName]), refFilePath, skillsRoot);
+      collectLocalRefsFromSchema(schema, fileSchemas, schemas, /* @__PURE__ */ new Set([typeName]), refFilePath, skillsRoot, sources);
       obj.$ref = `#/${typeName}`;
     }
   }
@@ -9453,11 +9796,11 @@ function rewriteRefsInSchema(obj, taskFilePath, skillsRoot, schemas) {
     if (Array.isArray(value)) {
       for (const item of value) {
         if (item && typeof item === "object") {
-          rewriteRefsInSchema(item, taskFilePath, skillsRoot, schemas);
+          rewriteRefsInSchema(item, taskFilePath, skillsRoot, schemas, sources);
         }
       }
     } else if (value && typeof value === "object") {
-      rewriteRefsInSchema(value, taskFilePath, skillsRoot, schemas);
+      rewriteRefsInSchema(value, taskFilePath, skillsRoot, schemas, sources);
     }
   }
 }
@@ -9478,19 +9821,21 @@ function getWorkflowStageDefinitions(fm3) {
 function getWorkflowTitle(fm3) {
   return fm3.title ?? fm3.workflow?.title ?? "";
 }
-function deriveArtifactName(filePath, agentsDir, frontmatter) {
+function deriveArtifactName(filePath, agentsDir, frontmatter, source2) {
   if (frontmatter?.type && typeof frontmatter.type === "string") {
     if (frontmatter.name && typeof frontmatter.name === "string" && frontmatter.name.includes(":")) {
       return frontmatter.name;
     }
     const bpName = frontmatter.name ?? filePath.replace(/\\/g, "/").split("/").pop()?.replace(/\.md$/, "") ?? "";
-    const rel2 = relative(resolve(agentsDir, "skills"), filePath).replace(/\\/g, "/");
-    const skill2 = rel2.split("/")[0] ?? "";
+    const skill2 = source2 ? source2.name : relative(resolve(agentsDir, "skills"), filePath).replace(/\\/g, "/").split("/")[0] ?? "";
     return `${skill2}:blueprints:${frontmatter.type}/${bpName}`;
   }
   if (frontmatter?.name && typeof frontmatter.name === "string") {
     return frontmatter.name;
   }
+  if (source2) {
+    return derivePluginArtifactName(source2, filePath);
+  }
   const rel = relative(resolve(agentsDir, "skills"), filePath).replace(/\\/g, "/");
   const parts = rel.split("/");
   const skill = parts[0] ?? "";
@@ -9603,30 +9948,23 @@ function buildEnvMap(config) {
   env["DESIGNBOOK_EXTENSION_SKILLS"] = getExtensionSkillIds(extensions);
   return env;
 }
-function buildWorktreeEnvMap(envMap, worktreePath, rootDir) {
-  const remapped = { ...envMap };
-  remapped["DESIGNBOOK_WORKSPACE"] = worktreePath;
-  for (const [key, value] of Object.entries(envMap)) {
-    if (!key.startsWith("DESIGNBOOK_DIRS_")) continue;
-    const relPath = relative(rootDir, value);
-    remapped[key] = resolve(worktreePath, relPath);
-  }
-  if (envMap["DESIGNBOOK_HOME"]) {
-    remapped["DESIGNBOOK_HOME"] = resolve(worktreePath, relative(rootDir, envMap["DESIGNBOOK_HOME"]));
+function resolveFiles(globPattern, context2, config, agentsDir, requireWhen = true, sources) {
+  const results = [];
+  const candidates = [];
+  for (const filePath of globSync(globPattern, { cwd: agentsDir, absolute: true })) {
+    candidates.push({ filePath });
   }
-  if (envMap["DESIGNBOOK_DATA"]) {
-    remapped["DESIGNBOOK_DATA"] = resolve(worktreePath, relative(rootDir, envMap["DESIGNBOOK_DATA"]));
+  const sourcePattern = toSourcePattern(globPattern);
+  for (const source2 of pluginSources(sources)) {
+    for (const filePath of globSync(sourcePattern, { cwd: source2.root, absolute: true })) {
+      candidates.push({ filePath, source: source2 });
+    }
   }
-  return remapped;
-}
-function resolveFiles(globPattern, context2, config, agentsDir, requireWhen = true) {
-  const results = [];
-  const paths = globSync(globPattern, { cwd: agentsDir, absolute: true });
-  for (const filePath of paths) {
+  for (const { filePath, source: source2 } of candidates) {
     const frontmatter = parseFrontmatter(filePath);
     const trigger = frontmatter?.trigger;
     const filter = frontmatter?.filter;
-    const name = deriveArtifactName(filePath, agentsDir, frontmatter);
+    const name = deriveArtifactName(filePath, agentsDir, frontmatter, source2);
     const triggerCount = trigger ? Object.keys(trigger).length : 0;
     const filterCount = filter ? Object.keys(filter).length : 0;
     if (triggerCount + filterCount === 0) {
@@ -9702,10 +10040,19 @@ function deduplicateByNameAs(files, agentsDir, warnings = []) {
   });
   return standalone;
 }
-function resolveTaskFilesRich(stage, config, agentsDir) {
+function resolveExplicitTaskInPluginSources(skillName, taskName, sources) {
+  const source2 = pluginSources(sources).find((s) => s.name === skillName);
+  if (!source2) return void 0;
+  const flat = resolve(source2.root, "tasks", `${taskName}.md`);
+  if (existsSync(flat)) return flat;
+  const nested = globSync(`**/tasks/${taskName}.md`, { cwd: source2.root, absolute: true });
+  if (nested.length > 0) return nested[0];
+  return void 0;
+}
+function resolveTaskFilesRich(stage, config, agentsDir, sources) {
   const context2 = buildRuntimeContext(stage);
   const enrichedConfig = buildEnrichedConfig(config);
-  const broadMatches = resolveFiles("skills/**/tasks/*.md", context2, enrichedConfig, agentsDir, true);
+  const broadMatches = resolveFiles("skills/**/tasks/*.md", context2, enrichedConfig, agentsDir, true, sources);
   if (stage.includes(":")) {
     if (broadMatches.length > 0) {
       broadMatches.sort((a, b) => b.specificity - a.specificity);
@@ -9723,12 +10070,29 @@ function resolveTaskFilesRich(stage, config, agentsDir) {
       const name = deriveArtifactName(taskPath, agentsDir, frontmatter);
       return [{ path: taskPath, name, specificity: 0, frontmatter }];
     }
+    const pluginTaskPath = resolveExplicitTaskInPluginSources(skillName, taskName, sources);
+    if (pluginTaskPath) {
+      console.warn(
+        `[designbook] task "${pluginTaskPath}" resolved by filename \u2014 add trigger.steps: [${stage}] to frontmatter`
+      );
+      const frontmatter = parseFrontmatter(pluginTaskPath);
+      const pluginSource = pluginSources(sources).find((s) => s.name === skillName);
+      const name = deriveArtifactName(pluginTaskPath, agentsDir, frontmatter, pluginSource);
+      return [{ path: pluginTaskPath, name, specificity: 0, frontmatter }];
+    }
     return [];
   }
   if (broadMatches.length > 0) {
     return deduplicateByNameAs(broadMatches, agentsDir);
   }
-  const filenameMatches = resolveFiles(`skills/**/tasks/${stage}.md`, context2, enrichedConfig, agentsDir, false);
+  const filenameMatches = resolveFiles(
+    `skills/**/tasks/${stage}.md`,
+    context2,
+    enrichedConfig,
+    agentsDir,
+    false,
+    sources
+  );
   if (filenameMatches.length > 0) {
     for (const m of filenameMatches) {
       console.warn(`[designbook] task "${m.path}" resolved by filename \u2014 add trigger.steps: [${stage}] to frontmatter`);
@@ -9737,22 +10101,22 @@ function resolveTaskFilesRich(stage, config, agentsDir) {
   }
   return [];
 }
-function matchRuleFiles(stage, config, agentsDir, extraConditions, effectiveDomains) {
+function matchRuleFiles(stage, config, agentsDir, extraConditions, effectiveDomains, sources) {
   const context2 = buildRuntimeContext(stage);
   if (effectiveDomains && effectiveDomains.length > 0) {
     context2["domain"] = effectiveDomains;
   }
   const enrichedConfig = buildEnrichedConfig(config);
-  const matches = resolveFiles("skills/**/rules/*.md", context2, enrichedConfig, agentsDir, true);
+  const matches = resolveFiles("skills/**/rules/*.md", context2, enrichedConfig, agentsDir, true, sources);
   return matches.map((m) => m.path);
 }
-function matchBlueprintFiles(stage, config, agentsDir, extraConditions, effectiveDomains) {
+function matchBlueprintFiles(stage, config, agentsDir, extraConditions, effectiveDomains, sources) {
   const context2 = buildRuntimeContext(stage);
   if (effectiveDomains && effectiveDomains.length > 0) {
     context2["domain"] = effectiveDomains;
   }
   const enrichedConfig = buildEnrichedConfig(config);
-  const matches = resolveFiles("skills/**/blueprints/*.md", context2, enrichedConfig, agentsDir, true);
+  const matches = resolveFiles("skills/**/blueprints/*.md", context2, enrichedConfig, agentsDir, true, sources);
   const byKey = /* @__PURE__ */ new Map();
   for (const m of matches) {
     const type = m.frontmatter?.["type"];
@@ -9908,9 +10272,9 @@ function resolveConfigForStep(stage, rawConfig) {
     config_instructions: [...explicitInstructions, ...extensionSkills]
   };
 }
-function resolveParamsRef(params, taskFilePath, skillsRoot) {
+function resolveParamsRef(params, taskFilePath, skillsRoot, sources) {
   const ref2 = params["$ref"];
-  const { schema } = resolveSchemaRef(ref2, taskFilePath, skillsRoot);
+  const { schema } = resolveSchemaRef(ref2, taskFilePath, skillsRoot, sources);
   const schemaObj = schema;
   const schemaProps = schemaObj.properties;
   if (!schemaProps) {
@@ -9997,7 +10361,7 @@ function generateTaskId(stage, params, _schemaParams, index = 0) {
   const hash = createHash("sha256").update(stage + JSON.stringify(params) + index).digest("hex").slice(0, 6);
   return `${baseName}-${hash}`;
 }
-async function resolveAllStages(workflowFilePath, config, rawConfig, agentsDir) {
+async function resolveAllStages(workflowFilePath, config, rawConfig, agentsDir, sources) {
   const wfFm = parseFrontmatter(workflowFilePath);
   const stageDefs = wfFm ? getWorkflowStageDefinitions(wfFm) : void 0;
   const allSteps = wfFm ? getWorkflowSteps(wfFm) : void 0;
@@ -10010,9 +10374,9 @@ async function resolveAllStages(workflowFilePath, config, rawConfig, agentsDir)
   const expectedParams = {};
   const collectedSchemas = {};
   for (const step of allSteps ?? []) {
-    let resolvedTaskFiles = resolveTaskFilesRich(step, config, agentsDir);
+    let resolvedTaskFiles = resolveTaskFilesRich(step, config, agentsDir, sources);
     if (resolvedTaskFiles.length === 0 && !step.includes(":") && workflowId) {
-      resolvedTaskFiles = resolveTaskFilesRich(`${workflowId}:${step}`, config, agentsDir);
+      resolvedTaskFiles = resolveTaskFilesRich(`${workflowId}:${step}`, config, agentsDir, sources);
     }
     if (resolvedTaskFiles.length === 0) {
       console.debug(`[Designbook] workflow: step "${step}" skipped \u2014 no matching task file`);
@@ -10051,13 +10415,13 @@ async function resolveAllStages(workflowFilePath, config, rawConfig, agentsDir)
     const effectiveDomainsArg = effectiveDomains.length > 0 ? effectiveDomains : void 0;
     const ruleFiles = [];
     for (const s of stepsToMatch) {
-      for (const r of matchRuleFiles(s, config, agentsDir, void 0, effectiveDomainsArg)) {
+      for (const r of matchRuleFiles(s, config, agentsDir, void 0, effectiveDomainsArg, sources)) {
         if (!ruleFiles.includes(r)) ruleFiles.push(r);
       }
     }
     const blueprintFiles = [];
     for (const s of stepsToMatch) {
-      for (const b of matchBlueprintFiles(s, config, agentsDir, void 0, effectiveDomainsArg)) {
+      for (const b of matchBlueprintFiles(s, config, agentsDir, void 0, effectiveDomainsArg, sources)) {
         if (!blueprintFiles.includes(b)) blueprintFiles.push(b);
       }
     }
@@ -10086,7 +10450,8 @@ async function resolveAllStages(workflowFilePath, config, rawConfig, agentsDir)
             ruleFiles,
             skillsRoot: resolve(agentsDir, "skills"),
             schemas: collectedSchemas,
-            refMap
+            refMap,
+            sources
           });
         }
       }
@@ -10097,7 +10462,8 @@ async function resolveAllStages(workflowFilePath, config, rawConfig, agentsDir)
       result: taskFmForSchema?.result,
       taskFilePath: primaryTaskFile,
       skillsRoot: resolve(agentsDir, "skills"),
-      envMap
+      envMap,
+      sources
     });
     if (mergedSchema) {
       for (const [resultKey, composedSchema] of Object.entries(mergedSchema)) {
@@ -10141,7 +10507,7 @@ async function resolveAllStages(workflowFilePath, config, rawConfig, agentsDir)
       let params = taskFm?.params;
       if (!params) continue;
       if ("$ref" in params) {
-        params = resolveParamsRef(params, taskFile, skillsRoot);
+        params = resolveParamsRef(params, taskFile, skillsRoot, sources);
       }
       validateParamFormats(params, taskFile);
       const properties = params.properties ?? {};
@@ -10240,292 +10606,30 @@ async function generateTaskTitle(stage, params, schemaParams, explicitTitle) {
   }
   return words;
 }
-
-// src/engines/git-worktree.ts
-function checkPreflightClean(rootDir, outputsRoot) {
-  try {
-    const relOutputsRoot = relative(rootDir, outputsRoot);
-    const output = execFileSync("git", ["-C", rootDir, "status", "--porcelain", "--", relOutputsRoot], {
-      encoding: "utf-8"
-    });
-    if (!output.trim()) return { clean: true, files: [] };
-    const files = output.split("\n").filter((line) => line.length >= 4).map((line) => line.slice(3).trim()).filter(Boolean);
-    return { clean: false, files };
-  } catch {
-    return { clean: true, files: [] };
-  }
+function getExpr(value) {
+  return typeof value === "string" ? value : value.expr;
 }
-function createGitWorktree(worktreePath, branchName, rootDir) {
-  execFileSync("git", ["worktree", "add", worktreePath, "-b", branchName], { cwd: rootDir });
-}
-var gitWorktreeEngine = {
-  writeFile(_data, task, key, content) {
-    const fileEntry = (task.files ?? []).find((f) => f.key === key);
-    if (!fileEntry) throw new Error(`No file entry with key '${key}' in task '${task.id}'`);
-    mkdirSync(dirname(fileEntry.path), { recursive: true });
-    writeFileSync(fileEntry.path, content);
-    return { path: fileEntry.path };
-  },
-  getStagedPath(_data, task, key) {
-    const fileEntry = (task.files ?? []).find((f) => f.key === key);
-    if (!fileEntry) throw new Error(`No file entry with key '${key}' in task '${task.id}'`);
-    return fileEntry.path;
-  },
-  flush() {
-  },
-  setup(ctx) {
-    if (ctx.dryRun) {
-      return { envMap: buildWorktreeEnvMap(ctx.envMap, ctx.worktreePath, ctx.rootDir) };
-    }
-    const branchName = `workflow/${ctx.workflowName}`;
-    const preflight = checkPreflightClean(ctx.rootDir, ctx.workspace);
-    if (!preflight.clean) {
-      const files = preflight.files.map((f) => `  \xB7 ${f}`).join("\n");
-      throw new Error(`Uncommitted changes in workspace \u2014 commit these files before running workflow plan:
-${files}`);
-    }
-    createGitWorktree(ctx.worktreePath, branchName, ctx.rootDir);
-    return {
-      envMap: buildWorktreeEnvMap(ctx.envMap, ctx.worktreePath, ctx.rootDir),
-      write_root: ctx.worktreePath,
-      worktree_branch: branchName
-    };
-  },
-  commit(data) {
-    if (!data.write_root || !data.worktree_branch || !data.workspace_root) return;
-    if (!existsSync(data.write_root)) return;
-    const outputTasks = data.tasks.filter((t) => t.type !== "test");
-    const outputPaths = outputTasks.flatMap((t) => (t.files ?? []).map((f) => f.path));
-    if (outputPaths.length > 0) {
-      const relPaths = outputPaths.map((p) => relative(data.write_root, p)).filter((r) => !r.startsWith(".."));
-      if (relPaths.length > 0) {
-        execFileSync("git", ["-C", data.write_root, "add", ...relPaths]);
-      }
-    }
-    execFileSync("git", ["-C", data.write_root, "commit", "--allow-empty", "-m", `workflow: ${data.worktree_branch}`]);
-    execFileSync("git", ["worktree", "remove", data.write_root, "--force"], { cwd: data.workspace_root });
-  },
-  merge(data) {
-    const branch = data.worktree_branch;
-    const rootDir = data.workspace_root;
-    if (!branch) throw new Error("Workflow has no worktree_branch \u2014 nothing to merge");
-    if (!rootDir) throw new Error("Workflow has no workspace_root");
-    execFileSync("git", ["-C", rootDir, "merge", "--squash", branch]);
-    execFileSync("git", ["-C", rootDir, "commit", "-m", `workflow: ${data.workflow}`]);
-    execFileSync("git", ["-C", rootDir, "branch", "-D", branch]);
-    return { branch, workspace_root: rootDir };
-  },
-  done() {
-    return { archive: false };
-  },
-  cleanup(data) {
-    if (data.write_root && existsSync(data.write_root)) {
-      try {
-        execFileSync("git", ["worktree", "remove", data.write_root, "--force"], { cwd: data.workspace_root });
-      } catch {
-      }
-    }
-    if (data.worktree_branch && data.workspace_root) {
-      try {
-        execFileSync("git", ["-C", data.workspace_root, "branch", "-D", data.worktree_branch]);
-      } catch {
-      }
-    }
-  },
-  onTransition(from, to, ctx) {
-    const { data } = ctx;
-    switch (`${from}\u2192${to}`) {
-      case "planned\u2192execute": {
-        if (!ctx.setupCtx) return {};
-        const result = gitWorktreeEngine.setup(ctx.setupCtx);
-        return {
-          envMap: result.envMap,
-          write_root: result.write_root,
-          worktree_branch: result.worktree_branch
-        };
-      }
-      case "execute\u2192committed": {
-        gitWorktreeEngine.commit(data);
-        return {};
-      }
-      case "committed\u2192test": {
-        return {};
-      }
-      case "finalizing\u2192done": {
-        if (!ctx.params?.merge_approved) {
-          return {
-            requires: {
-              merge_approved: {
-                type: "boolean",
-                prompt: "Branch {branch} mergen?"
-              }
-            }
-          };
-        }
-        const mergeResult = gitWorktreeEngine.merge(data);
-        return { archive: true, branch: mergeResult.branch };
-      }
-      default:
-        if (to === "abandoned") {
-          gitWorktreeEngine.cleanup(data);
-        }
-        return {};
-    }
-  }
-};
-function deboSuffix(data) {
-  if (!data.workflow_id) throw new Error("workflow_id is required for direct engine stash-at-target");
-  return `.${data.workflow_id}.debo`;
-}
-function stashPath(data, fileEntry) {
-  return fileEntry.path + deboSuffix(data);
-}
-var directEngine = {
-  setup(ctx) {
-    return { envMap: ctx.envMap };
-  },
-  writeFile(data, task, key, content) {
-    const fileEntry = (task.files ?? []).find((f) => f.key === key);
-    if (!fileEntry) throw new Error(`No file entry with key '${key}' in task '${task.id}'`);
-    const path = stashPath(data, fileEntry);
-    mkdirSync(dirname(path), { recursive: true });
-    writeFileSync(path, content);
-    return { path };
-  },
-  getStagedPath(data, task, key) {
-    const fileEntry = (task.files ?? []).find((f) => f.key === key);
-    if (fileEntry) return stashPath(data, fileEntry);
-    const resultEntry = task.result?.[key];
-    if (resultEntry?.path) {
-      return resultEntry.path;
-    }
-    throw new Error(`No file entry with key '${key}' in task '${task.id}'`);
-  },
-  flush(data, tasks) {
-    const suffix = deboSuffix(data);
-    const now = (/* @__PURE__ */ new Date()).toISOString();
-    for (const task of tasks) {
-      for (const file of task.files ?? []) {
-        if (!file.validation_result) continue;
-        const src = file.path + suffix;
-        if (!existsSync(src)) continue;
-        mkdirSync(dirname(file.path), { recursive: true });
-        renameSync(src, file.path);
-        file.flushed_at = now;
-      }
-    }
-    return Promise.resolve();
-  },
-  commit() {
-  },
-  merge() {
-    throw new Error('Engine "direct" does not support merge \u2014 files are already written to real paths');
-  },
-  done() {
-    return { archive: true };
-  },
-  cleanup(data) {
-    const suffix = deboSuffix(data);
-    const dirs = /* @__PURE__ */ new Set();
-    for (const task of data.tasks) {
-      for (const file of task.files ?? []) {
-        dirs.add(dirname(file.path));
-      }
-    }
-    for (const dir of dirs) {
-      if (!existsSync(dir)) continue;
-      try {
-        const entries = readdirSync(dir);
-        for (const entry of entries) {
-          if (entry.endsWith(suffix)) {
-            unlinkSync(resolve(dir, entry));
-          }
-        }
-      } catch {
-      }
-    }
-  },
-  async onTransition(from, to, ctx) {
-    const declared = ctx.data.stages ? Object.keys(ctx.data.stages) : [];
-    if (declared.includes(from)) {
-      const stageTasks = ctx.data.tasks.filter((t) => t.stage === from);
-      if (stageTasks.length > 0) {
-        await directEngine.flush(ctx.data, stageTasks);
-      }
-    }
-    if (from === "finalizing" && to === "done") {
-      return { archive: true };
-    }
-    return {};
-  }
-};
-
-// src/engines/index.ts
-var engines = {
-  "git-worktree": gitWorktreeEngine,
-  direct: directEngine
-};
-
-// src/workflow-lifecycle.ts
-var IMPLICIT_STAGES = {
-  _after_declared: ["committed"],
-  _before_done: ["finalizing", "done"]
-};
-function buildLifecycleOrder(stages) {
-  const declared = Object.keys(stages).filter((s) => (stages[s].steps?.length ?? 0) > 0);
-  return ["created", "planned", ...declared, ...IMPLICIT_STAGES._after_declared, ...IMPLICIT_STAGES._before_done];
-}
-function getNextStage(current, stages) {
-  const order = buildLifecycleOrder(stages);
-  const currentIdx = order.indexOf(current);
-  if (currentIdx === -1 || currentIdx >= order.length - 1) return null;
-  return order[currentIdx + 1] ?? null;
-}
-function getNextStep(currentStage, _completedStep, tasks) {
-  const pending = tasks.find((t) => t.stage === currentStage && t.status !== "done");
-  return pending?.step ?? null;
-}
-function checkStageParams(stage, stages, provided) {
-  const def = stages[stage];
-  if (!def?.params) return null;
-  const unfulfilled = {};
-  for (const [key, param] of Object.entries(def.params)) {
-    if (provided[key] === void 0) {
-      unfulfilled[key] = param;
-    }
-  }
-  return Object.keys(unfulfilled).length > 0 ? unfulfilled : null;
-}
-function interpolatePrompt(prompt, state) {
-  return prompt.replace(/\{(\w+)\}/g, (_match, key) => {
-    const value = state[key];
-    return value !== void 0 ? String(value) : `{${key}}`;
-  });
-}
-function getExpr(value) {
-  return typeof value === "string" ? value : value.expr;
-}
-async function resolveEach(each, scope) {
-  const entries = Object.entries(each);
-  if (entries.length === 0) return [];
-  let combos = [{}];
-  for (const [binding, raw] of entries) {
-    const expr = getExpr(raw);
-    const next = [];
-    for (const combo of combos) {
-      const innerScope = { ...scope, ...combo };
-      const value = await jsonata9(expr).evaluate(innerScope);
-      if (value === void 0 || value === null) continue;
-      const items = Array.isArray(value) ? value : [value];
-      for (const item of items) {
-        next.push({ ...combo, [binding]: item });
-      }
-    }
-    combos = next;
-    if (combos.length === 0) break;
-  }
-  const total = combos.length;
-  return combos.map((c, i) => ({ ...c, $i: i, $total: total }));
+async function resolveEach(each, scope) {
+  const entries = Object.entries(each);
+  if (entries.length === 0) return [];
+  let combos = [{}];
+  for (const [binding, raw] of entries) {
+    const expr = getExpr(raw);
+    const next = [];
+    for (const combo of combos) {
+      const innerScope = { ...scope, ...combo };
+      const value = await jsonata9(expr).evaluate(innerScope);
+      if (value === void 0 || value === null) continue;
+      const items = Array.isArray(value) ? value : [value];
+      for (const item of items) {
+        next.push({ ...combo, [binding]: item });
+      }
+    }
+    combos = next;
+    if (combos.length === 0) break;
+  }
+  const total = combos.length;
+  return combos.map((c, i) => ({ ...c, $i: i, $total: total }));
 }
 
 // src/workflow.ts
@@ -10581,9 +10685,8 @@ function renderSubmitResultsHint(taskId, results) {
 }
 
 // src/workflow.ts
-function resolveWorkflowEngine(data) {
-  const name = data.engine ?? (data.worktree_branch ? "git-worktree" : "direct");
-  return engines[name];
+function resolveWorkflowEngine(_data) {
+  return engines["direct"];
 }
 function timestamp() {
   const d = /* @__PURE__ */ new Date();
@@ -10613,11 +10716,6 @@ function readWorkflow(filePath) {
     throw new Error(`Workflow not found: ${name}`);
   }
   const data = load(readFileSync(filePath, "utf-8"));
-  const legacy = data;
-  if (!data.workspace_root && legacy.root_dir) {
-    data.workspace_root = legacy.root_dir;
-  }
-  delete legacy.root_dir;
   resolveWorkflowPaths(data);
   return data;
 }
@@ -10709,7 +10807,7 @@ function workflowAbandon(dataDir, name) {
   const changesDir = resolve(dataDir, "workflows", "changes", name);
   const filePath = resolve(changesDir, "tasks.yml");
   const data = readWorkflow(filePath);
-  const engine = resolveWorkflowEngine(data);
+  const engine = resolveWorkflowEngine();
   if (engine) engine.cleanup(data);
   data.status = "incomplete";
   data.completed_at = timestamp();
@@ -10804,16 +10902,6 @@ function resolveWorkflowPaths(data) {
 function relativizeWorkflowPaths(data) {
   return transformWorkflowPaths(data, relativizePath);
 }
-function workflowMerge(dataDir, name) {
-  const changesDir = resolve(dataDir, "workflows", "changes", name);
-  const filePath = resolve(changesDir, "tasks.yml");
-  const data = readWorkflow(filePath);
-  const engine = resolveWorkflowEngine(data);
-  if (!engine) throw new Error(`Unknown engine: "${data.engine}"`);
-  const result = engine.merge(data);
-  archiveAndCascade(dataDir, name, data);
-  return result;
-}
 function workflowList(dataDir, workflowId, includeArchived) {
   const changesDir = resolve(dataDir, "workflows", "changes");
   const active = existsSync(changesDir) ? readdirSync(changesDir).filter((name) => name.startsWith(`${workflowId}-`)) : [];
@@ -11055,455 +11143,439 @@ async function expandTasksFromParams(stageLoaded, stages, params, existingTasks,
 async function workflowDone(dataDir, name, taskId, loaded, options) {
   const changesDir = resolve(dataDir, "workflows", "changes", name);
   const filePath = resolve(changesDir, "tasks.yml");
-  return withLockAsync(filePath, async () => {
-    const data = readWorkflow(filePath);
-    data._changesDir = changesDir;
-    const task = data.tasks.find((t) => t.id === taskId);
-    if (!task) {
-      throw new Error(`Task not found: ${taskId} (available: ${data.tasks.map((t) => t.id).join(", ")})`);
-    }
-    if (task.status === "done") {
-      throw new Error(`Task '${taskId}' is already done`);
-    }
-    if (options?.data && task.result) {
-      const dataPayload = options.data;
-      const declaredKeys = new Set(Object.keys(task.result));
-      const unknownKeys = Object.keys(dataPayload).filter((k) => !declaredKeys.has(k));
-      if (unknownKeys.length > 0) {
-        throw new Error(
-          `Unknown result key(s) in --data: ${unknownKeys.join(", ")}. Valid keys: ${[...declaredKeys].join(", ")}`
+  const data = readWorkflow(filePath);
+  data._changesDir = changesDir;
+  const task = data.tasks.find((t) => t.id === taskId);
+  if (!task) {
+    throw new Error(`Task not found: ${taskId} (available: ${data.tasks.map((t) => t.id).join(", ")})`);
+  }
+  if (task.status === "done") {
+    throw new Error(`Task '${taskId}' is already done`);
+  }
+  if (options?.data && task.result) {
+    const dataPayload = options.data;
+    const declaredKeys = new Set(Object.keys(task.result));
+    const unknownKeys = Object.keys(dataPayload).filter((k) => !declaredKeys.has(k));
+    if (unknownKeys.length > 0) {
+      throw new Error(
+        `Unknown result key(s) in --data: ${unknownKeys.join(", ")}. Valid keys: ${[...declaredKeys].join(", ")}`
+      );
+    }
+    const validationErrors = [];
+    for (const [key, rawValue] of Object.entries(dataPayload)) {
+      const value = rawValue;
+      const resultEntry = task.result[key];
+      if (!resultEntry) continue;
+      if (resultEntry.path) {
+        if (/\{\{[^}]*\}\}/.test(resultEntry.path)) {
+          throw new Error(`result path template unresolved: ${resultEntry.path}`);
+        }
+        const { serializeForPath: serializeForPath2 } = await Promise.resolve().then(() => (init_workflow_serialize(), workflow_serialize_exports));
+        const serialized = serializeForPath2(
+          resultEntry.path,
+          value,
+          resultEntry.schema
         );
-      }
-      const validationErrors = [];
-      for (const [key, rawValue] of Object.entries(dataPayload)) {
-        const value = rawValue;
-        const resultEntry = task.result[key];
-        if (!resultEntry) continue;
-        if (resultEntry.path) {
-          if (/\{\{[^}]*\}\}/.test(resultEntry.path)) {
-            throw new Error(`result path template unresolved: ${resultEntry.path}`);
-          }
-          const { serializeForPath: serializeForPath2 } = await Promise.resolve().then(() => (init_workflow_serialize(), workflow_serialize_exports));
-          const serialized = serializeForPath2(
-            resultEntry.path,
-            value,
-            resultEntry.schema
-          );
-          const engine2 = resolveWorkflowEngine(data);
-          const dataWithDir = data;
-          dataWithDir._changesDir = changesDir;
-          if (!task.files?.some((f) => f.key === key)) {
-            task.files = task.files ?? [];
-            task.files.push({ path: resultEntry.path, key, validators: resultEntry.validators ?? [] });
-          }
-          let writtenPath;
-          if (engine2?.writeFile) {
-            const result = engine2.writeFile(dataWithDir, task, key, serialized);
-            writtenPath = result.path;
-          } else {
-            const dir = dirname(resultEntry.path);
-            mkdirSync(dir, { recursive: true });
-            writeFileSync(resultEntry.path, serialized);
-            writtenPath = resultEntry.path;
-          }
-          const config = options.config ?? { data: dataDir, technology: "html", extensions: [] };
-          const schemaErrors = await validateResultEntry(resultEntry, value, data.schemas, config, "data");
-          const semanticErrors = resultEntry.validators && resultEntry.validators.length > 0 ? await validateResultEntry(
-            { ...resultEntry, schema: void 0 },
-            writtenPath,
-            data.schemas,
-            config,
-            "file"
-          ) : [];
-          const errors = [...schemaErrors, ...semanticErrors];
-          if (errors.length > 0) {
-            validationErrors.push(...errors.map((e) => `${key}: ${e}`));
-            resultEntry.valid = false;
-            resultEntry.error = errors.join("; ");
-          } else {
-            resultEntry.valid = true;
-            delete resultEntry.error;
-          }
-          resultEntry.last_validated = (/* @__PURE__ */ new Date()).toISOString();
-          const fileEntry = task.files?.find((f) => f.key === key);
-          if (fileEntry) {
-            fileEntry.validation_result = {
-              file: resultEntry.path,
-              type: key,
-              valid: resultEntry.valid,
-              error: resultEntry.error,
-              last_validated: resultEntry.last_validated,
-              last_passed: resultEntry.valid ? resultEntry.last_validated : void 0,
-              last_failed: !resultEntry.valid ? resultEntry.last_validated : void 0
-            };
-          }
-          if (resultEntry.flush === "immediate" && writtenPath !== resultEntry.path) {
-            mkdirSync(dirname(resultEntry.path), { recursive: true });
-            renameSync(writtenPath, resultEntry.path);
-            resultEntry.flushed_at = (/* @__PURE__ */ new Date()).toISOString();
-            if (fileEntry) fileEntry.flushed_at = resultEntry.flushed_at;
-          }
+        const engine2 = resolveWorkflowEngine();
+        const dataWithDir = data;
+        dataWithDir._changesDir = changesDir;
+        if (!task.files?.some((f) => f.key === key)) {
+          task.files = task.files ?? [];
+          task.files.push({ path: resultEntry.path, key, validators: resultEntry.validators ?? [] });
+        }
+        let writtenPath;
+        if (engine2?.writeFile) {
+          const result = engine2.writeFile(dataWithDir, task, key, serialized);
+          writtenPath = result.path;
         } else {
-          const config = options.config ?? { data: dataDir, technology: "html", extensions: [] };
-          const errors = await validateResultEntry(resultEntry, value, data.schemas, config, "data");
-          if (errors.length > 0) {
-            validationErrors.push(...errors.map((e) => `${key}: ${e}`));
-            resultEntry.valid = false;
-            resultEntry.error = errors.join("; ");
-          } else {
-            resultEntry.value = value;
-            resultEntry.valid = true;
-            delete resultEntry.error;
-          }
-          resultEntry.last_validated = (/* @__PURE__ */ new Date()).toISOString();
+          const dir = dirname(resultEntry.path);
+          mkdirSync(dir, { recursive: true });
+          writeFileSync(resultEntry.path, serialized);
+          writtenPath = resultEntry.path;
+        }
+        const config = options.config ?? { data: dataDir, technology: "html", extensions: [] };
+        const schemaErrors = await validateResultEntry(resultEntry, value, data.schemas, config, "data");
+        const semanticErrors = resultEntry.validators && resultEntry.validators.length > 0 ? await validateResultEntry(
+          { ...resultEntry, schema: void 0 },
+          writtenPath,
+          data.schemas,
+          config,
+          "file"
+        ) : [];
+        const errors = [...schemaErrors, ...semanticErrors];
+        if (errors.length > 0) {
+          validationErrors.push(...errors.map((e) => `${key}: ${e}`));
+          resultEntry.valid = false;
+          resultEntry.error = errors.join("; ");
+        } else {
+          resultEntry.valid = true;
+          delete resultEntry.error;
+        }
+        resultEntry.last_validated = (/* @__PURE__ */ new Date()).toISOString();
+        const fileEntry = task.files?.find((f) => f.key === key);
+        if (fileEntry) {
+          fileEntry.validation_result = {
+            file: resultEntry.path,
+            type: key,
+            valid: resultEntry.valid,
+            error: resultEntry.error,
+            last_validated: resultEntry.last_validated,
+            last_passed: resultEntry.valid ? resultEntry.last_validated : void 0,
+            last_failed: !resultEntry.valid ? resultEntry.last_validated : void 0
+          };
         }
-      }
-      if (validationErrors.length > 0) {
-        writeWorkflowAtomic(filePath, data);
-        return {
-          archived: false,
-          data,
-          response: {
-            stage: data.current_stage ?? "unknown",
-            validation_errors: validationErrors
-          }
-        };
-      }
-    }
-    if (task.result) {
-      const directWrites = [];
-      for (const [key, resultEntry] of Object.entries(task.result)) {
-        if (!resultEntry.path) continue;
-        if (resultEntry.valid !== void 0) continue;
-        if (resultEntry.submission === "direct") continue;
-        if (/\{[a-zA-Z]\w*\}/.test(resultEntry.path)) continue;
-        if (existsSync(resultEntry.path)) {
-          directWrites.push(`  \xB7 result \`${key}\` at \`${resultEntry.path}\``);
+        if (resultEntry.flush === "immediate" && writtenPath !== resultEntry.path) {
+          mkdirSync(dirname(resultEntry.path), { recursive: true });
+          renameSync(writtenPath, resultEntry.path);
+          resultEntry.flushed_at = (/* @__PURE__ */ new Date()).toISOString();
+          if (fileEntry) fileEntry.flushed_at = resultEntry.flushed_at;
         }
-      }
-      if (directWrites.length > 0) {
-        const hintResults = Object.fromEntries(
-          Object.entries(task.result).map(([k, v]) => {
-            const schema = v.schema;
-            return [
-              k,
-              {
-                path: v.path,
-                submission: v.submission,
-                flush: v.flush,
-                $ref: typeof schema?.$ref === "string" ? schema.$ref : void 0,
-                type: typeof schema?.type === "string" ? schema.type : void 0
-              }
-            ];
-          })
-        );
-        const hint = renderSubmitResultsHint(taskId, hintResults) ?? "";
-        throw new Error(
-          `Cannot mark '${taskId}' as done \u2014 ${directWrites.length} file result(s) were written directly instead of via \`workflow done --data\`:
-` + directWrites.join("\n") + "\n\n" + hint
-        );
+      } else {
+        const config = options.config ?? { data: dataDir, technology: "html", extensions: [] };
+        const errors = await validateResultEntry(resultEntry, value, data.schemas, config, "data");
+        if (errors.length > 0) {
+          validationErrors.push(...errors.map((e) => `${key}: ${e}`));
+          resultEntry.valid = false;
+          resultEntry.error = errors.join("; ");
+        } else {
+          resultEntry.value = value;
+          resultEntry.valid = true;
+          delete resultEntry.error;
+        }
+        resultEntry.last_validated = (/* @__PURE__ */ new Date()).toISOString();
       }
     }
-    if (task.result) {
-      for (const [, resultEntry] of Object.entries(task.result)) {
-        if (resultEntry.valid !== void 0) continue;
-        if (resultEntry.path) continue;
-        if (resultEntry.schema && typeof resultEntry.schema === "object" && "default" in resultEntry.schema) {
-          resultEntry.value = resultEntry.schema.default;
-          resultEntry.valid = true;
-          resultEntry.last_validated = (/* @__PURE__ */ new Date()).toISOString();
+    if (validationErrors.length > 0) {
+      writeWorkflowAtomic(filePath, data);
+      return {
+        archived: false,
+        data,
+        response: {
+          stage: data.current_stage ?? "unknown",
+          validation_errors: validationErrors
         }
+      };
+    }
+  }
+  if (task.result) {
+    const directWrites = [];
+    for (const [key, resultEntry] of Object.entries(task.result)) {
+      if (!resultEntry.path) continue;
+      if (resultEntry.valid !== void 0) continue;
+      if (resultEntry.submission === "direct") continue;
+      if (/\{[a-zA-Z]\w*\}/.test(resultEntry.path)) continue;
+      if (existsSync(resultEntry.path)) {
+        directWrites.push(`  \xB7 result \`${key}\` at \`${resultEntry.path}\``);
       }
     }
-    const hasUnresolvedPlaceholder = (f) => /\{[a-zA-Z]\w*\}/.test(f.path);
-    const taskFiles = task.files ?? [];
-    if (taskFiles.length > 0 && taskFiles.every((f) => hasUnresolvedPlaceholder(f)) && !taskFiles.some((f) => f.validation_result)) {
+    if (directWrites.length > 0) {
+      const hintResults = Object.fromEntries(
+        Object.entries(task.result).map(([k, v]) => {
+          const schema = v.schema;
+          return [
+            k,
+            {
+              path: v.path,
+              submission: v.submission,
+              flush: v.flush,
+              $ref: typeof schema?.$ref === "string" ? schema.$ref : void 0,
+              type: typeof schema?.type === "string" ? schema.type : void 0
+            }
+          ];
+        })
+      );
+      const hint = renderSubmitResultsHint(taskId, hintResults) ?? "";
       throw new Error(
-        `Cannot mark '${taskId}' as done \u2014 all file paths have unresolved placeholders and no files were written:
-` + taskFiles.map((f) => `  \xB7 \`${f.path}\``).join("\n")
+        `Cannot mark '${taskId}' as done \u2014 ${directWrites.length} file result(s) were written directly instead of via \`workflow done --data\`:
+` + directWrites.join("\n") + "\n\n" + hint
       );
     }
-    const notWritten = taskFiles.filter((f) => !f.validation_result && !hasUnresolvedPlaceholder(f));
-    if (notWritten.length > 0) {
-      throw new Error(
-        `Cannot mark '${taskId}' as done \u2014 ${notWritten.length} file(s) not yet written:
+  }
+  if (task.result) {
+    for (const [, resultEntry] of Object.entries(task.result)) {
+      if (resultEntry.valid !== void 0) continue;
+      if (resultEntry.path) continue;
+      if (resultEntry.schema && typeof resultEntry.schema === "object" && "default" in resultEntry.schema) {
+        resultEntry.value = resultEntry.schema.default;
+        resultEntry.valid = true;
+        resultEntry.last_validated = (/* @__PURE__ */ new Date()).toISOString();
+      }
+    }
+  }
+  const hasUnresolvedPlaceholder = (f) => /\{[a-zA-Z]\w*\}/.test(f.path);
+  const taskFiles = task.files ?? [];
+  if (taskFiles.length > 0 && taskFiles.every((f) => hasUnresolvedPlaceholder(f)) && !taskFiles.some((f) => f.validation_result)) {
+    throw new Error(
+      `Cannot mark '${taskId}' as done \u2014 all file paths have unresolved placeholders and no files were written:
+` + taskFiles.map((f) => `  \xB7 \`${f.path}\``).join("\n")
+    );
+  }
+  const notWritten = taskFiles.filter((f) => !f.validation_result && !hasUnresolvedPlaceholder(f));
+  if (notWritten.length > 0) {
+    throw new Error(
+      `Cannot mark '${taskId}' as done \u2014 ${notWritten.length} file(s) not yet written:
 ` + notWritten.map((f) => `  \xB7 file \`${f.key}\` not yet written`).join("\n")
+    );
+  }
+  const failed = (task.files ?? []).filter((f) => f.validation_result?.valid === false);
+  if (failed.length > 0) {
+    throw new Error(
+      `Cannot mark '${taskId}' as done \u2014 ${failed.length} file(s) have errors:
+` + failed.map((f) => `  \xB7 file \`${f.key}\` has errors: ${f.validation_result?.error ?? "invalid"}`).join("\n")
+    );
+  }
+  if (task.result) {
+    const missingResults = Object.entries(task.result).filter(
+      ([, r]) => r.valid === void 0 && r.path !== void 0 && r.required !== false
+    );
+    if (missingResults.length > 0) {
+      throw new Error(
+        `Cannot mark '${taskId}' as done \u2014 ${missingResults.length} result(s) not yet written:
+` + missingResults.map(([k]) => `  \xB7 result \`${k}\` not yet written`).join("\n")
       );
     }
-    const failed = (task.files ?? []).filter((f) => f.validation_result?.valid === false);
-    if (failed.length > 0) {
+    const missingDataResults = Object.entries(task.result).filter(
+      ([, r]) => r.valid === void 0 && r.path === void 0 && r.required !== false
+    );
+    if (missingDataResults.length > 0) {
       throw new Error(
-        `Cannot mark '${taskId}' as done \u2014 ${failed.length} file(s) have errors:
-` + failed.map((f) => `  \xB7 file \`${f.key}\` has errors: ${f.validation_result?.error ?? "invalid"}`).join("\n")
+        `Cannot mark '${taskId}' as done \u2014 ${missingDataResults.length} data result(s) not yet written:
+` + missingDataResults.map(([k]) => `  \xB7 result \`${k}\` not yet written`).join("\n")
       );
     }
-    if (task.result) {
-      const missingResults = Object.entries(task.result).filter(
-        ([, r]) => r.valid === void 0 && r.path !== void 0 && r.required !== false
-      );
-      if (missingResults.length > 0) {
-        throw new Error(
-          `Cannot mark '${taskId}' as done \u2014 ${missingResults.length} result(s) not yet written:
-` + missingResults.map(([k]) => `  \xB7 result \`${k}\` not yet written`).join("\n")
-        );
-      }
-      const missingDataResults = Object.entries(task.result).filter(
-        ([, r]) => r.valid === void 0 && r.path === void 0 && r.required !== false
-      );
-      if (missingDataResults.length > 0) {
-        throw new Error(
-          `Cannot mark '${taskId}' as done \u2014 ${missingDataResults.length} data result(s) not yet written:
-` + missingDataResults.map(([k]) => `  \xB7 result \`${k}\` not yet written`).join("\n")
-        );
-      }
-      const failedResults = Object.entries(task.result).filter(([, r]) => r.valid === false);
-      if (failedResults.length > 0) {
-        throw new Error(
-          `Cannot mark '${taskId}' as done \u2014 ${failedResults.length} result(s) have errors:
+    const failedResults = Object.entries(task.result).filter(([, r]) => r.valid === false);
+    if (failedResults.length > 0) {
+      throw new Error(
+        `Cannot mark '${taskId}' as done \u2014 ${failedResults.length} result(s) have errors:
 ` + failedResults.map(([k, r]) => `  \xB7 result \`${k}\` has errors: ${r.error ?? "invalid"}`).join("\n")
-        );
-      }
+      );
     }
-    task.status = "done";
-    if (!task.started_at) task.started_at = timestamp();
-    task.completed_at = timestamp();
-    if (options?.summary) task.summary = options.summary;
-    if (loaded) {
-      const stepName = task.step;
-      if (stepName) {
-        data.stage_loaded = data.stage_loaded ?? {};
-        if (!data.stage_loaded[stepName]) {
-          data.stage_loaded[stepName] = {
-            task_file: loaded.task_file ?? "",
-            rules: loaded.rules ?? [],
-            blueprints: loaded.blueprints ?? [],
-            config_rules: loaded.config_rules ?? [],
-            config_instructions: loaded.config_instructions ?? [],
-            ...loaded.isolate ? { isolate: true } : {}
-          };
-        }
+  }
+  task.status = "done";
+  if (!task.started_at) task.started_at = timestamp();
+  task.completed_at = timestamp();
+  if (options?.summary) task.summary = options.summary;
+  if (loaded) {
+    const stepName = task.step;
+    if (stepName) {
+      data.stage_loaded = data.stage_loaded ?? {};
+      if (!data.stage_loaded[stepName]) {
+        data.stage_loaded[stepName] = {
+          task_file: loaded.task_file ?? "",
+          rules: loaded.rules ?? [],
+          blueprints: loaded.blueprints ?? [],
+          config_rules: loaded.config_rules ?? [],
+          config_instructions: loaded.config_instructions ?? [],
+          ...loaded.isolate ? { isolate: true } : {}
+        };
       }
     }
-    const engine = resolveWorkflowEngine(data);
-    const hasGroupedStages = data.stages && typeof data.stages === "object" && !Array.isArray(data.stages);
-    if (hasGroupedStages && data.current_stage) {
-      const stages = data.stages;
-      const currentStage = data.current_stage;
-      const configForExpansion = options?.config ?? { data: dataDir, technology: "html", extensions: [] };
-      const getMissingStageSteps = (stageName) => {
-        const stageDef = stages[stageName];
-        if (!stageDef?.steps) return [];
-        const stageHasTrackedSteps = data.tasks.some((t) => t.stage === stageName && typeof t.step === "string" && t.step.length > 0) || stageDef.steps.some((step) => Boolean(data.stage_loaded?.[step]));
-        if (!stageHasTrackedSteps) return [];
-        return stageDef.steps.filter((step) => !data.tasks.some((t) => t.stage === stageName && t.step === step));
-      };
-      const expandStageIfNeeded = async (stageName) => {
-        const missingBefore = getMissingStageSteps(stageName);
-        if (missingBefore.length === 0) return {};
-        if (!data.stage_loaded) return {};
-        const stageLoaded = data.stage_loaded;
-        const scopeEnvMap = data.env_map ?? {};
-        const stageDef = stages[stageName];
-        if (!stageDef) return {};
-        let expandedFromScope;
-        let resolverErrors;
-        const resolveResult = await resolveStageTaskParams(
-          stageLoaded,
-          stageDef,
-          data.params ?? {},
-          configForExpansion
+  }
+  const engine = resolveWorkflowEngine();
+  const hasGroupedStages = data.stages && typeof data.stages === "object" && !Array.isArray(data.stages);
+  if (hasGroupedStages && data.current_stage) {
+    const stages = data.stages;
+    const currentStage = data.current_stage;
+    const configForExpansion = options?.config ?? { data: dataDir, technology: "html", extensions: [] };
+    const getMissingStageSteps = (stageName) => {
+      const stageDef = stages[stageName];
+      if (!stageDef?.steps) return [];
+      const stageHasTrackedSteps = data.tasks.some((t) => t.stage === stageName && typeof t.step === "string" && t.step.length > 0) || stageDef.steps.some((step) => Boolean(data.stage_loaded?.[step]));
+      if (!stageHasTrackedSteps) return [];
+      return stageDef.steps.filter((step) => !data.tasks.some((t) => t.stage === stageName && t.step === step));
+    };
+    const expandStageIfNeeded = async (stageName) => {
+      const missingBefore = getMissingStageSteps(stageName);
+      if (missingBefore.length === 0) return {};
+      if (!data.stage_loaded) return {};
+      const stageLoaded = data.stage_loaded;
+      const scopeEnvMap = data.env_map ?? {};
+      const stageDef = stages[stageName];
+      if (!stageDef) return {};
+      let expandedFromScope;
+      let resolverErrors;
+      const resolveResult = await resolveStageTaskParams(stageLoaded, stageDef, data.params ?? {}, configForExpansion);
+      data.params = resolveResult.params;
+      if (Object.keys(resolveResult.unresolved).length > 0) {
+        resolverErrors = Object.fromEntries(
+          Object.entries(resolveResult.unresolved).map(([k, v]) => [k, { input: v.input, error: v.error }])
         );
-        data.params = resolveResult.params;
-        if (Object.keys(resolveResult.unresolved).length > 0) {
-          resolverErrors = Object.fromEntries(
-            Object.entries(resolveResult.unresolved).map(([k, v]) => [k, { input: v.input, error: v.error }])
+      }
+      const expanded = await expandTasksFromParams(
+        stageLoaded,
+        { [stageName]: stageDef },
+        resolveResult.params,
+        data.tasks,
+        scopeEnvMap,
+        data.scope,
+        options?.config
+      );
+      if (expanded.length > 0) {
+        data.tasks.push(...expanded);
+        const pluginSkillSources = options?.config ? resolvePluginSkillSources({ env: process.env, home: homedir(), config: options.config })?.sources ?? [] : [];
+        const skillsRoot = deriveSkillsRootFromTaskFile(expanded[0]?.task_file) ?? (expanded[0]?.task_file ? dirname(expanded[0].task_file) : void 0);
+        if (skillsRoot) {
+          const mergedSchemas = resolveSchemasForTasks(
+            expanded,
+            skillsRoot,
+            { ...data.schemas ?? {} },
+            pluginSkillSources
           );
-        }
-        const expanded = await expandTasksFromParams(
-          stageLoaded,
-          { [stageName]: stageDef },
-          resolveResult.params,
-          data.tasks,
-          scopeEnvMap,
-          data.scope,
-          options?.config
-        );
-        if (expanded.length > 0) {
-          data.tasks.push(...expanded);
-          const skillsRoot = deriveSkillsRootFromTaskFile(expanded[0]?.task_file);
-          if (skillsRoot) {
-            const mergedSchemas = resolveSchemasForTasks(expanded, skillsRoot, { ...data.schemas ?? {} });
-            if (Object.keys(mergedSchemas).length > 0) {
-              data.schemas = mergedSchemas;
-            }
+          if (Object.keys(mergedSchemas).length > 0) {
+            data.schemas = mergedSchemas;
           }
-          expandedFromScope = expanded.map((t) => ({
-            id: t.id,
-            step: t.step,
-            stage: t.stage,
-            title: t.title
-          }));
         }
-        return { expandedFromScope, resolverErrors };
-      };
-      const formatResolverErrors = (resolverErrors) => {
-        if (!resolverErrors || Object.keys(resolverErrors).length === 0) return "";
-        const details = Object.entries(resolverErrors).map(([key, value]) => `  \xB7 ${key}: ${value.error ?? "unresolved"}`).join("\n");
-        return `
+        expandedFromScope = expanded.map((t) => ({
+          id: t.id,
+          step: t.step,
+          stage: t.stage,
+          title: t.title
+        }));
+      }
+      return { expandedFromScope, resolverErrors };
+    };
+    const formatResolverErrors = (resolverErrors) => {
+      if (!resolverErrors || Object.keys(resolverErrors).length === 0) return "";
+      const details = Object.entries(resolverErrors).map(([key, value]) => `  \xB7 ${key}: ${value.error ?? "unresolved"}`).join("\n");
+      return `
 Resolver errors:
 ${details}`;
+    };
+    const nextStepInStage = getNextStep(currentStage, task.step ?? "", data.tasks);
+    const stageTasks = data.tasks.filter((t) => t.stage === currentStage);
+    const stageDone = stageTasks.filter((t) => t.status === "done").length;
+    const stageTotal = stageTasks.length;
+    let response;
+    if (nextStepInStage) {
+      const nextTask = data.tasks.find((t) => t.step === nextStepInStage && t.status === "pending");
+      if (nextTask) {
+        nextTask.status = "in-progress";
+        nextTask.started_at = timestamp();
+      }
+      response = {
+        stage: currentStage,
+        step_completed: task.step,
+        next_step: nextStepInStage,
+        stage_progress: `${stageDone}/${stageTotal}`,
+        stage_complete: false
+      };
+      writeWorkflowAtomic(filePath, data);
+      return { archived: false, data, response };
+    }
+    const currentStageExpansion = await expandStageIfNeeded(currentStage);
+    const nextTaskInCurrentStage = data.tasks.find((t) => t.stage === currentStage && t.status !== "done");
+    if (nextTaskInCurrentStage) {
+      if (nextTaskInCurrentStage.status === "pending") {
+        nextTaskInCurrentStage.status = "in-progress";
+        nextTaskInCurrentStage.started_at = timestamp();
+      }
+      response = {
+        stage: currentStage,
+        step_completed: task.step,
+        next_step: nextTaskInCurrentStage.step ?? null,
+        stage_progress: `${stageDone}/${stageTotal}`,
+        stage_complete: false,
+        ...currentStageExpansion.expandedFromScope && { expanded_tasks: currentStageExpansion.expandedFromScope },
+        ...currentStageExpansion.resolverErrors && { resolver_errors: currentStageExpansion.resolverErrors }
       };
-      const nextStepInStage = getNextStep(currentStage, task.step ?? "", data.tasks);
-      const stageTasks = data.tasks.filter((t) => t.stage === currentStage);
-      const stageDone = stageTasks.filter((t) => t.status === "done").length;
-      const stageTotal = stageTasks.length;
-      let response;
-      if (nextStepInStage) {
-        const nextTask = data.tasks.find((t) => t.step === nextStepInStage && t.status === "pending");
-        if (nextTask) {
-          nextTask.status = "in-progress";
-          nextTask.started_at = timestamp();
+      writeWorkflowAtomic(filePath, data);
+      return { archived: false, data, response };
+    }
+    const missingCurrentSteps = getMissingStageSteps(currentStage);
+    if (missingCurrentSteps.length > 0) {
+      throw new Error(
+        `Cannot complete stage '${currentStage}' \u2014 step(s) not materialized: ${missingCurrentSteps.join(", ")}` + formatResolverErrors(currentStageExpansion.resolverErrors)
+      );
+    }
+    const scopeUpdate = collectStageResults(stageTasks);
+    if (Object.keys(scopeUpdate).length > 0) {
+      data.scope = { ...data.scope ?? {}, ...scopeUpdate };
+    }
+    let fromStage = currentStage;
+    let nextStage = getNextStage(fromStage, stages);
+    while (nextStage) {
+      if (engine) {
+        const transitionResult = await engine.onTransition(fromStage, nextStage, { data });
+        if (transitionResult.archive) {
+          data.current_stage = "done";
+          const transitionResponse = {
+            stage: "done",
+            stage_progress: `${stageDone}/${stageTotal}`,
+            stage_complete: true,
+            ...Object.keys(scopeUpdate).length > 0 && { scope_update: scopeUpdate }
+          };
+          const held2 = holdForAfter(filePath, data, options?.after, transitionResponse);
+          if (held2) return held2;
+          archiveAndCascade(dataDir, name, data);
+          return { archived: true, data, response: transitionResponse };
+        }
+      }
+      const unfulfilledParams = checkStageParams(nextStage, stages, data.params ?? {});
+      if (unfulfilledParams) {
+        data.current_stage = nextStage;
+        const promptState = {};
+        const interpolated = {};
+        for (const [key, param] of Object.entries(unfulfilledParams)) {
+          interpolated[key] = { ...param, prompt: interpolatePrompt(param.prompt, promptState) };
         }
-        response = {
-          stage: currentStage,
-          step_completed: task.step,
-          next_step: nextStepInStage,
-          stage_progress: `${stageDone}/${stageTotal}`,
-          stage_complete: false
-        };
         writeWorkflowAtomic(filePath, data);
-        return { archived: false, data, response };
+        return { archived: false, data, response: { stage: nextStage, waiting_for: interpolated } };
       }
-      const currentStageExpansion = await expandStageIfNeeded(currentStage);
-      const nextTaskInCurrentStage = data.tasks.find((t) => t.stage === currentStage && t.status !== "done");
-      if (nextTaskInCurrentStage) {
-        if (nextTaskInCurrentStage.status === "pending") {
-          nextTaskInCurrentStage.status = "in-progress";
-          nextTaskInCurrentStage.started_at = timestamp();
+      const { expandedFromScope, resolverErrors } = await expandStageIfNeeded(nextStage);
+      const nextStepInNewStage = data.tasks.find((t) => t.stage === nextStage && t.status !== "done");
+      if (nextStepInNewStage) {
+        if (nextStepInNewStage.status === "pending") {
+          nextStepInNewStage.status = "in-progress";
+          nextStepInNewStage.started_at = timestamp();
         }
+        data.current_stage = nextStage;
         response = {
-          stage: currentStage,
-          step_completed: task.step,
-          next_step: nextTaskInCurrentStage.step ?? null,
+          stage: nextStage,
+          transition_from: currentStage,
+          next_stage: nextStage,
+          next_step: nextStepInNewStage.step ?? null,
           stage_progress: `${stageDone}/${stageTotal}`,
-          stage_complete: false,
-          ...currentStageExpansion.expandedFromScope && { expanded_tasks: currentStageExpansion.expandedFromScope },
-          ...currentStageExpansion.resolverErrors && { resolver_errors: currentStageExpansion.resolverErrors }
+          stage_complete: true,
+          ...Object.keys(scopeUpdate).length > 0 && { scope_update: scopeUpdate },
+          ...expandedFromScope && { expanded_tasks: expandedFromScope },
+          ...resolverErrors && { resolver_errors: resolverErrors }
         };
         writeWorkflowAtomic(filePath, data);
         return { archived: false, data, response };
       }
-      const missingCurrentSteps = getMissingStageSteps(currentStage);
-      if (missingCurrentSteps.length > 0) {
+      const missingNextSteps = getMissingStageSteps(nextStage);
+      if (missingNextSteps.length > 0) {
         throw new Error(
-          `Cannot complete stage '${currentStage}' \u2014 step(s) not materialized: ${missingCurrentSteps.join(", ")}` + formatResolverErrors(currentStageExpansion.resolverErrors)
+          `Cannot enter stage '${nextStage}' \u2014 step(s) not materialized: ${missingNextSteps.join(", ")}` + formatResolverErrors(resolverErrors)
         );
       }
-      const scopeUpdate = collectStageResults(stageTasks);
-      if (Object.keys(scopeUpdate).length > 0) {
-        data.scope = { ...data.scope ?? {}, ...scopeUpdate };
-      }
-      let fromStage = currentStage;
-      let nextStage = getNextStage(fromStage, stages);
-      while (nextStage) {
-        if (engine) {
-          const transitionResult = await engine.onTransition(fromStage, nextStage, { data });
-          if (transitionResult.requires) {
-            const promptState = {
-              branch: data.worktree_branch
-            };
-            const interpolated = {};
-            for (const [key, param] of Object.entries(transitionResult.requires)) {
-              interpolated[key] = { ...param, prompt: interpolatePrompt(param.prompt, promptState) };
-            }
-            data.current_stage = fromStage;
-            writeWorkflowAtomic(filePath, data);
-            return { archived: false, data, response: { stage: fromStage, waiting_for: interpolated } };
-          }
-          if (transitionResult.archive) {
-            data.current_stage = "done";
-            const transitionResponse = {
-              stage: "done",
-              stage_progress: `${stageDone}/${stageTotal}`,
-              stage_complete: true,
-              ...Object.keys(scopeUpdate).length > 0 && { scope_update: scopeUpdate }
-            };
-            const held2 = holdForAfter(filePath, data, options?.after, transitionResponse);
-            if (held2) return held2;
-            archiveAndCascade(dataDir, name, data);
-            return { archived: true, data, response: transitionResponse };
-          }
-        }
-        const unfulfilledParams = checkStageParams(nextStage, stages, data.params ?? {});
-        if (unfulfilledParams) {
-          data.current_stage = nextStage;
-          const promptState = {
-            branch: data.worktree_branch
-          };
-          const interpolated = {};
-          for (const [key, param] of Object.entries(unfulfilledParams)) {
-            interpolated[key] = { ...param, prompt: interpolatePrompt(param.prompt, promptState) };
-          }
-          writeWorkflowAtomic(filePath, data);
-          return { archived: false, data, response: { stage: nextStage, waiting_for: interpolated } };
-        }
-        const { expandedFromScope, resolverErrors } = await expandStageIfNeeded(nextStage);
-        const nextStepInNewStage = data.tasks.find((t) => t.stage === nextStage && t.status !== "done");
-        if (nextStepInNewStage) {
-          if (nextStepInNewStage.status === "pending") {
-            nextStepInNewStage.status = "in-progress";
-            nextStepInNewStage.started_at = timestamp();
-          }
-          data.current_stage = nextStage;
-          response = {
-            stage: nextStage,
-            transition_from: currentStage,
-            next_stage: nextStage,
-            next_step: nextStepInNewStage.step ?? null,
-            stage_progress: `${stageDone}/${stageTotal}`,
-            stage_complete: true,
-            ...Object.keys(scopeUpdate).length > 0 && { scope_update: scopeUpdate },
-            ...expandedFromScope && { expanded_tasks: expandedFromScope },
-            ...resolverErrors && { resolver_errors: resolverErrors }
-          };
-          writeWorkflowAtomic(filePath, data);
-          return { archived: false, data, response };
-        }
-        const missingNextSteps = getMissingStageSteps(nextStage);
-        if (missingNextSteps.length > 0) {
-          throw new Error(
-            `Cannot enter stage '${nextStage}' \u2014 step(s) not materialized: ${missingNextSteps.join(", ")}` + formatResolverErrors(resolverErrors)
-          );
-        }
-        fromStage = nextStage;
-        nextStage = getNextStage(fromStage, stages);
+      fromStage = nextStage;
+      nextStage = getNextStage(fromStage, stages);
+    }
+    data.current_stage = "done";
+    const completionResponse = {
+      stage: "done",
+      stage_progress: `${stageDone}/${stageTotal}`,
+      stage_complete: true,
+      ...Object.keys(scopeUpdate).length > 0 && { scope_update: scopeUpdate }
+    };
+    if (engine) {
+      if (engine.flush) {
+        await engine.flush(data, data.tasks);
       }
-      data.current_stage = "done";
-      const completionResponse = {
-        stage: "done",
-        stage_progress: `${stageDone}/${stageTotal}`,
-        stage_complete: true,
-        ...Object.keys(scopeUpdate).length > 0 && { scope_update: scopeUpdate }
-      };
-      if (engine) {
-        if (engine.flush) {
-          await engine.flush(data, data.tasks);
-        }
-        const doneResult = engine.done(data);
-        if (doneResult.archive) {
-          const held2 = holdForAfter(filePath, data, options?.after, completionResponse);
-          if (held2) return held2;
-          archiveAndCascade(dataDir, name, data);
-          return { archived: true, data, response: completionResponse };
-        }
+      {
+        const held2 = holdForAfter(filePath, data, options?.after, completionResponse);
+        if (held2) return held2;
+        archiveAndCascade(dataDir, name, data);
+        return { archived: true, data, response: completionResponse };
       }
-      const held = holdForAfter(filePath, data, options?.after, completionResponse);
-      if (held) return held;
-      writeWorkflowAtomic(filePath, data);
-      return { archived: false, data, response: completionResponse };
     }
-    throw new Error("Workflow has no grouped stages \u2014 all workflows require stages in frontmatter");
-  });
+    const held = holdForAfter(filePath, data, options?.after, completionResponse);
+    if (held) return held;
+    writeWorkflowAtomic(filePath, data);
+    return { archived: false, data, response: completionResponse };
+  }
+  throw new Error("Workflow has no grouped stages \u2014 all workflows require stages in frontmatter");
 }
 function workflowGetFile(dataDir, name, taskId, key) {
   const changesDir = resolve(dataDir, "workflows", "changes", name);
@@ -11524,7 +11596,7 @@ function workflowGetFile(dataDir, name, taskId, key) {
     const validKeys = [...fileKeys, ...resultKeys].join(", ");
     throw new Error(`Unknown key '${key}' for task '${taskId}'. Valid keys: ${validKeys}`);
   }
-  const engine = resolveWorkflowEngine(data);
+  const engine = resolveWorkflowEngine();
   const dataWithDir = data;
   dataWithDir._changesDir = changesDir;
   const staged_path = engine?.getStagedPath ? engine.getStagedPath(dataWithDir, task, key) : fileEntry.path;
@@ -11554,112 +11626,110 @@ function collectStageResults(stageTasks) {
 async function workflowResult(dataDir, name, taskId, key, content, config) {
   const changesDir = resolve(dataDir, "workflows", "changes", name);
   const filePath = resolve(changesDir, "tasks.yml");
-  return withLockAsync(filePath, async () => {
-    const data = readWorkflow(filePath);
-    const task = data.tasks.find((t) => t.id === taskId);
-    if (!task) {
-      throw new Error(`Task not found: ${taskId} (available: ${data.tasks.map((t) => t.id).join(", ")})`);
-    }
-    if (!task.result) {
-      throw new Error(`Task '${taskId}' has no result declarations`);
-    }
-    const resultEntry = task.result[key];
-    if (!resultEntry) {
-      const validKeys = Object.keys(task.result).join(", ");
-      throw new Error(`Unknown result key '${key}' for task '${taskId}'. Valid keys: ${validKeys}`);
-    }
-    const isFileResult = !!resultEntry.path;
-    const errors = [];
-    if (isFileResult) {
-      if (resultEntry.submission !== "direct") {
-        throw new Error(
-          `Result '${key}' is not declared as \`submission: direct\`. Submit file results via \`workflow done --data '{"` + key + "\": ...}'` instead."
-        );
-      }
-      const engine = resolveWorkflowEngine(data);
-      const dataWithDir = data;
-      dataWithDir._changesDir = changesDir;
-      if (!task.files?.some((f) => f.key === key)) {
-        task.files = task.files ?? [];
-        task.files.push({
-          path: resultEntry.path,
-          key,
-          validators: resultEntry.validators ?? []
-        });
-      }
-      let writtenPath;
-      if (engine?.getStagedPath) {
-        const staged = engine.getStagedPath(dataWithDir, task, key);
-        writtenPath = existsSync(staged) ? staged : resultEntry.path;
-      } else {
-        writtenPath = resultEntry.path;
-      }
-      if (!existsSync(writtenPath)) {
-        throw new Error(`External file not found at path: ${writtenPath}`);
-      }
-      const validationErrors2 = await validateResultEntry(resultEntry, writtenPath, data.schemas, config, "file");
-      if (validationErrors2.length > 0) {
-        errors.push(...validationErrors2);
-        resultEntry.valid = false;
-        resultEntry.error = validationErrors2.join("; ");
-      } else {
-        resultEntry.valid = true;
-        delete resultEntry.error;
-      }
-      resultEntry.last_validated = (/* @__PURE__ */ new Date()).toISOString();
-      const fileEntry = task.files?.find((f) => f.key === key);
-      if (fileEntry) {
-        fileEntry.validation_result = {
-          file: resultEntry.path,
-          type: key,
-          valid: resultEntry.valid,
-          error: resultEntry.error,
-          last_validated: resultEntry.last_validated,
-          last_passed: resultEntry.valid ? resultEntry.last_validated : void 0,
-          last_failed: !resultEntry.valid ? resultEntry.last_validated : void 0
-        };
-      }
-      if (resultEntry.flush === "immediate" && writtenPath !== resultEntry.path) {
-        mkdirSync(dirname(resultEntry.path), { recursive: true });
-        renameSync(writtenPath, resultEntry.path);
-        resultEntry.flushed_at = (/* @__PURE__ */ new Date()).toISOString();
-        if (fileEntry) fileEntry.flushed_at = resultEntry.flushed_at;
-        writtenPath = resultEntry.path;
-      }
-      writeWorkflowAtomic(filePath, data);
-      return {
-        valid: errors.length === 0,
-        errors,
-        file_path: writtenPath
-      };
+  const data = readWorkflow(filePath);
+  const task = data.tasks.find((t) => t.id === taskId);
+  if (!task) {
+    throw new Error(`Task not found: ${taskId} (available: ${data.tasks.map((t) => t.id).join(", ")})`);
+  }
+  if (!task.result) {
+    throw new Error(`Task '${taskId}' has no result declarations`);
+  }
+  const resultEntry = task.result[key];
+  if (!resultEntry) {
+    const validKeys = Object.keys(task.result).join(", ");
+    throw new Error(`Unknown result key '${key}' for task '${taskId}'. Valid keys: ${validKeys}`);
+  }
+  const isFileResult = !!resultEntry.path;
+  const errors = [];
+  if (isFileResult) {
+    if (resultEntry.submission !== "direct") {
+      throw new Error(
+        `Result '${key}' is not declared as \`submission: direct\`. Submit file results via \`workflow done --data '{"` + key + "\": ...}'` instead."
+      );
     }
-    let dataValue;
-    if (typeof content === "string") {
-      try {
-        dataValue = JSON.parse(content);
-      } catch {
-        throw new Error(`Data result '${key}' requires valid JSON, got: ${content.slice(0, 100)}`);
-      }
+    const engine = resolveWorkflowEngine();
+    const dataWithDir = data;
+    dataWithDir._changesDir = changesDir;
+    if (!task.files?.some((f) => f.key === key)) {
+      task.files = task.files ?? [];
+      task.files.push({
+        path: resultEntry.path,
+        key,
+        validators: resultEntry.validators ?? []
+      });
+    }
+    let writtenPath;
+    if (engine?.getStagedPath) {
+      const staged = engine.getStagedPath(dataWithDir, task, key);
+      writtenPath = existsSync(staged) ? staged : resultEntry.path;
     } else {
-      dataValue = content;
+      writtenPath = resultEntry.path;
     }
-    const validationErrors = await validateResultEntry(resultEntry, dataValue, data.schemas, config, "data");
-    if (validationErrors.length > 0) {
-      errors.push(...validationErrors);
+    if (!existsSync(writtenPath)) {
+      throw new Error(`External file not found at path: ${writtenPath}`);
+    }
+    const validationErrors2 = await validateResultEntry(resultEntry, writtenPath, data.schemas, config, "file");
+    if (validationErrors2.length > 0) {
+      errors.push(...validationErrors2);
       resultEntry.valid = false;
-      resultEntry.error = validationErrors.join("; ");
+      resultEntry.error = validationErrors2.join("; ");
     } else {
-      resultEntry.value = dataValue;
       resultEntry.valid = true;
       delete resultEntry.error;
     }
     resultEntry.last_validated = (/* @__PURE__ */ new Date()).toISOString();
+    const fileEntry = task.files?.find((f) => f.key === key);
+    if (fileEntry) {
+      fileEntry.validation_result = {
+        file: resultEntry.path,
+        type: key,
+        valid: resultEntry.valid,
+        error: resultEntry.error,
+        last_validated: resultEntry.last_validated,
+        last_passed: resultEntry.valid ? resultEntry.last_validated : void 0,
+        last_failed: !resultEntry.valid ? resultEntry.last_validated : void 0
+      };
+    }
+    if (resultEntry.flush === "immediate" && writtenPath !== resultEntry.path) {
+      mkdirSync(dirname(resultEntry.path), { recursive: true });
+      renameSync(writtenPath, resultEntry.path);
+      resultEntry.flushed_at = (/* @__PURE__ */ new Date()).toISOString();
+      if (fileEntry) fileEntry.flushed_at = resultEntry.flushed_at;
+      writtenPath = resultEntry.path;
+    }
     writeWorkflowAtomic(filePath, data);
     return {
       valid: errors.length === 0,
-      errors
+      errors,
+      file_path: writtenPath
     };
-  });
+  }
+  let dataValue;
+  if (typeof content === "string") {
+    try {
+      dataValue = JSON.parse(content);
+    } catch {
+      throw new Error(`Data result '${key}' requires valid JSON, got: ${content.slice(0, 100)}`);
+    }
+  } else {
+    dataValue = content;
+  }
+  const validationErrors = await validateResultEntry(resultEntry, dataValue, data.schemas, config, "data");
+  if (validationErrors.length > 0) {
+    errors.push(...validationErrors);
+    resultEntry.valid = false;
+    resultEntry.error = validationErrors.join("; ");
+  } else {
+    resultEntry.value = dataValue;
+    resultEntry.valid = true;
+    delete resultEntry.error;
+  }
+  resultEntry.last_validated = (/* @__PURE__ */ new Date()).toISOString();
+  writeWorkflowAtomic(filePath, data);
+  return {
+    valid: errors.length === 0,
+    errors
+  };
 }
 async function validateResultEntry(entry, content, schemas, config, mode) {
   const errors = [];
@@ -11856,20 +11926,30 @@ function register2(workflow) {
 
 // src/cli/workflow-discovery.ts
 init_esm4();
-function resolveWorkflowFile(workflowId, agentsDir) {
+function pluginSources2(sources) {
+  return (sources ?? []).filter((s) => s.origin === "plugin");
+}
+function resolveWorkflowFile(workflowId, agentsDir, sources) {
   const matches = globSync(`skills/**/workflows/${workflowId}.md`, { cwd: agentsDir, absolute: true });
-  if (matches.length === 0) {
-    throw new Error(`Workflow file not found for "${workflowId}". No match for skills/**/workflows/${workflowId}.md`);
+  if (matches.length > 0) return matches[0];
+  for (const source2 of pluginSources2(sources)) {
+    const found = globSync(`**/workflows/${workflowId}.md`, { cwd: source2.root, absolute: true });
+    if (found.length > 0) return found[0];
   }
-  return matches[0];
+  throw new Error(`Workflow file not found for "${workflowId}". No match for skills/**/workflows/${workflowId}.md`);
 }
-function listWorkflowDefinitions(agentsDir) {
+function listWorkflowDefinitions(agentsDir, sources) {
   const matches = globSync(`skills/**/workflows/*.md`, { cwd: agentsDir, absolute: true });
   const ids = matches.map((p) => basename(p, ".md"));
+  for (const source2 of pluginSources2(sources)) {
+    for (const p of globSync(`**/workflows/*.md`, { cwd: source2.root, absolute: true })) {
+      ids.push(basename(p, ".md"));
+    }
+  }
   return Array.from(new Set(ids)).sort();
 }
-function loadWorkflowDefinition(workflowId, agentsDir) {
-  const file = resolveWorkflowFile(workflowId, agentsDir);
+function loadWorkflowDefinition(workflowId, agentsDir, sources) {
+  const file = resolveWorkflowFile(workflowId, agentsDir, sources);
   const raw = readFileSync(file, "utf8");
   const fmMatch = raw.match(/^---\n([\s\S]*?)\n---/);
   if (!fmMatch) {
@@ -11936,8 +12016,9 @@ async function runWorkflowCreate(opts, config) {
   const rawConfig = configPath ? load(readFileSync(configPath, "utf-8")) ?? {} : {};
   const configDir = configPath ? dirname(configPath) : process.cwd();
   const agentsDir = resolveSkillsRoot(configDir);
-  const workflowFilePath = resolveWorkflowFile(opts.workflow, agentsDir);
-  const resolved = await resolveAllStages(workflowFilePath, config, rawConfig, agentsDir);
+  const sources = resolveSkillSources(configDir);
+  const workflowFilePath = resolveWorkflowFile(opts.workflow, agentsDir, sources);
+  const resolved = await resolveAllStages(workflowFilePath, config, rawConfig, agentsDir, sources);
   const wfFm = parseFrontmatter(workflowFilePath);
   const wfParamsRaw = wfFm?.params;
   const wfParams = wfParamsRaw ? { ...wfParamsRaw } : Object.values(resolved.expected_params).some((p) => p.resolve) ? {} : void 0;
@@ -12007,7 +12088,7 @@ async function runWorkflowCreate(opts, config) {
       const skillsRoot = resolve(agentsDir, "skills");
       for (const [key, decl] of Object.entries(resultDeclProperties)) {
         if (decl.$ref && firstResult[key]) {
-          const { typeName, schema } = resolveSchemaRef(decl.$ref, firstResolved.task_file, skillsRoot);
+          const { typeName, schema } = resolveSchemaRef(decl.$ref, firstResolved.task_file, skillsRoot, sources);
           firstSchemas[typeName] = schema;
           firstResult[key].schema = schema;
         }
@@ -12016,7 +12097,8 @@ async function runWorkflowCreate(opts, config) {
             firstResult[key].schema,
             firstResolved.task_file,
             skillsRoot,
-            firstSchemas
+            firstSchemas,
+            sources
           );
         }
       }
@@ -12169,13 +12251,14 @@ function register3(program2) {
     const configPath = findConfig();
     const configDir = configPath ? dirname(configPath) : process.cwd();
     const agentsDir = resolveSkillsRoot(configDir);
+    const sources = resolveSkillSources(configDir);
     if (!workflowId) {
-      const ids = listWorkflowDefinitions(agentsDir);
+      const ids = listWorkflowDefinitions(agentsDir, sources);
       for (const id of ids) console.log(id);
       return;
     }
     try {
-      const def = loadWorkflowDefinition(workflowId, agentsDir);
+      const def = loadWorkflowDefinition(workflowId, agentsDir, sources);
       console.log(JSON.stringify(def, null, 2));
     } catch (err) {
       console.error(`Error: ${err.message}`);
@@ -12319,7 +12402,8 @@ function register3(program2) {
         const configPath = findConfig();
         const configDir = configPath ? dirname(configPath) : process.cwd();
         const agentsDir = resolveSkillsRoot(configDir);
-        allAfter = loadWorkflowDefinition(workflowId, agentsDir).after;
+        const sources = resolveSkillSources(configDir);
+        allAfter = loadWorkflowDefinition(workflowId, agentsDir, sources).after;
         parentParams = parentMeta.params ?? {};
       } catch (lookupErr) {
         console.warn(`Could not load after: declarations \u2014 proceeding without: ${lookupErr.message}`);
@@ -12425,19 +12509,6 @@ RESPONSE: ${JSON.stringify(response)}`);
       process.exitCode = 1;
     }
   });
-  workflow.command("merge").description("Squash-merge a workflow branch, kill preview, and archive the workflow").requiredOption("--workflow <name>", "Workflow name (e.g., debo-vision-2026-03-17-a3f7)").action((opts) => {
-    const config = loadConfig();
-    try {
-      const result = workflowMerge(config.data, opts.workflow);
-      log({ cmd: "workflow merge", args: { workflow: opts.workflow }, result: { branch: result.branch } });
-      console.log(`\u2713 Workflow ${opts.workflow} merged and archived`);
-      console.log(`  Branch:  ${result.branch} (deleted)`);
-      console.log(`  Commit:  workflow: ${opts.workflow}`);
-    } catch (err) {
-      console.error(`Error: ${err.message}`);
-      process.exitCode = 1;
-    }
-  });
   register2(workflow);
 }
 
@@ -12697,13 +12768,13 @@ function collectRefNamesFromSchema(schema) {
     Object.values(obj).forEach(walk2);
   }
 }
-async function buildRenderContext(workflowFilePath, agentsDir) {
+async function buildRenderContext(workflowFilePath, agentsDir, sources) {
   const config = loadConfig();
   const configPath = findConfig();
   const rawConfig = configPath ? load(readFileSync(configPath, "utf-8")) ?? {} : {};
   const skillsRoot = resolve(agentsDir, "skills");
   const envMap = buildEnvMap(config);
-  const resolved = await resolveAllStages(workflowFilePath, config, rawConfig, agentsDir);
+  const resolved = await resolveAllStages(workflowFilePath, config, rawConfig, agentsDir, sources);
   const wfFm = parseFrontmatter(workflowFilePath) ?? {};
   const workflowId = workflowFilePath.split("/").pop().replace(/\.md$/, "");
   const taskBodies = /* @__PURE__ */ new Map();
@@ -12752,7 +12823,8 @@ async function buildRenderContext(workflowFilePath, agentsDir) {
           result: resultFm,
           taskFilePath: rs.task_file,
           skillsRoot,
-          envMap
+          envMap,
+          sources
         });
         const schemaObj = buildResultSchemaObject(schemaBlock.result);
         outputSchemas.set(step, schemaObj);
@@ -13006,8 +13078,9 @@ function register5(program2) {
       const configPath = findConfig();
       const configDir = configPath ? dirname(configPath) : process.cwd();
       const agentsDir = resolveSkillsRoot(configDir);
-      const workflowFile = resolveWorkflowFile(workflowId, agentsDir);
-      const ctx = await buildRenderContext(workflowFile, agentsDir);
+      const sources = resolveSkillSources(configDir);
+      const workflowFile = resolveWorkflowFile(workflowId, agentsDir, sources);
+      const ctx = await buildRenderContext(workflowFile, agentsDir, sources);
       const md = renderPlan(ctx);
       console.log(md);
     } catch (err) {
@@ -13188,4 +13261,7 @@ register3(program);
 register4(program);
 register5(program);
 register6(program);
-program.parse();
+program.parseAsync(process.argv).catch((err) => {
+  console.error(err instanceof Error ? err.message : String(err));
+  process.exitCode = 1;
+});