@tagma/sdk 0.4.3 → 0.4.5

package/src/registry.ts

@@ -1,214 +1,214 @@
-import type {
-  PluginCategory, DriverPlugin, TriggerPlugin,
-  CompletionPlugin, MiddlewarePlugin, PluginManifest,
-} from './types';
-
-type PluginType = DriverPlugin | TriggerPlugin | CompletionPlugin | MiddlewarePlugin;
-
-const VALID_CATEGORIES: ReadonlySet<PluginCategory> = new Set([
-  'drivers', 'triggers', 'completions', 'middlewares',
-]);
-
-const registries = {
-  drivers:     new Map<string, DriverPlugin>(),
-  triggers:    new Map<string, TriggerPlugin>(),
-  completions: new Map<string, CompletionPlugin>(),
-  middlewares: new Map<string, MiddlewarePlugin>(),
-};
-
-/**
- * Minimal contract enforcement so a malformed plugin fails fast at
- * registration time rather than crashing the engine mid-run.
- *
- * For drivers we materialize `capabilities` and assert each field is a
- * boolean — otherwise a plugin author can write
- *     get capabilities() { throw new Error('boom') }
- * and pass the basic typeof check, then crash preflight when the engine
- * touches `driver.capabilities.sessionResume`. (R8)
- */
-function validateContract(category: PluginCategory, handler: unknown): void {
-  if (!handler || typeof handler !== 'object') {
-    throw new Error(`Plugin handler for category "${category}" must be an object`);
-  }
-  const h = handler as Record<string, unknown>;
-  if (typeof h.name !== 'string' || h.name.length === 0) {
-    throw new Error(`Plugin handler for category "${category}" must declare a non-empty "name"`);
-  }
-  switch (category) {
-    case 'drivers': {
-      if (typeof h.buildCommand !== 'function') {
-        throw new Error(`drivers plugin "${h.name}" must export buildCommand()`);
-      }
-      // Materialize capabilities — this triggers any throwing getter NOW
-      // instead of during preflight.
-      let caps: unknown;
-      try {
-        caps = h.capabilities;
-      } catch (err) {
-        throw new Error(
-          `drivers plugin "${h.name}" capabilities accessor threw: ` +
-          (err instanceof Error ? err.message : String(err))
-        );
-      }
-      if (!caps || typeof caps !== 'object') {
-        throw new Error(`drivers plugin "${h.name}" must declare capabilities object`);
-      }
-      const c = caps as Record<string, unknown>;
-      for (const field of ['sessionResume', 'systemPrompt', 'outputFormat'] as const) {
-        if (typeof c[field] !== 'boolean') {
-          throw new Error(
-            `drivers plugin "${h.name}".capabilities.${field} must be a boolean (got ${typeof c[field]})`
-          );
-        }
-      }
-      // Optional methods, but if present must be functions.
-      for (const opt of ['parseResult', 'resolveModel', 'resolveTools'] as const) {
-        if (h[opt] !== undefined && typeof h[opt] !== 'function') {
-          throw new Error(
-            `drivers plugin "${h.name}".${opt} must be a function or undefined`
-          );
-        }
-      }
-      break;
-    }
-    case 'triggers':
-      if (typeof h.watch !== 'function') {
-        throw new Error(`triggers plugin "${h.name}" must export watch()`);
-      }
-      break;
-    case 'completions':
-      if (typeof h.check !== 'function') {
-        throw new Error(`completions plugin "${h.name}" must export check()`);
-      }
-      break;
-    case 'middlewares':
-      if (typeof h.enhance !== 'function') {
-        throw new Error(`middlewares plugin "${h.name}" must export enhance()`);
-      }
-      break;
-  }
-}
-
-export type RegisterResult = 'registered' | 'replaced' | 'unchanged';
-
-/**
- * Register a plugin under (category, type). Returns:
- *   - 'registered' on first registration
- *   - 'replaced'   when an existing entry was overwritten with a different handler
- *   - 'unchanged'  when the same handler instance was already present
- *
- * Throws if `category` is unknown, `type` is empty, or `handler` violates the
- * minimum interface contract for the category.
- */
-export function registerPlugin<T extends PluginType>(
-  category: PluginCategory, type: string, handler: T,
-): RegisterResult {
-  if (!VALID_CATEGORIES.has(category)) {
-    throw new Error(`Unknown plugin category "${category}"`);
-  }
-  if (typeof type !== 'string' || type.length === 0) {
-    throw new Error(`Plugin type must be a non-empty string (category="${category}")`);
-  }
-  validateContract(category, handler);
-  const registry = registries[category] as Map<string, T>;
-  const existing = registry.get(type);
-  if (existing === handler) return 'unchanged';
-  const wasReplaced = existing !== undefined;
-  registry.set(type, handler);
-  return wasReplaced ? 'replaced' : 'registered';
-}
-
-/**
- * Remove a plugin from the in-process registry. Returns true if a plugin
- * was actually removed. Note: ESM module caching is not affected, so
- * re-importing the same file after unregister will yield the cached module —
- * callers wanting a fresh load must restart the host process.
- */
-export function unregisterPlugin(category: PluginCategory, type: string): boolean {
-  if (!VALID_CATEGORIES.has(category)) return false;
-  return registries[category].delete(type);
-}
-
-export function getHandler<T extends PluginType>(
-  category: PluginCategory, type: string,
-): T {
-  const handler = registries[category].get(type);
-  if (!handler) {
-    throw new Error(
-      `${category} type "${type}" not registered.\n` +
-      `Install the plugin: bun add @tagma/${category.replace(/s$/, '')}-${type}`
-    );
-  }
-  return handler as T;
-}
-
-export function hasHandler(category: PluginCategory, type: string): boolean {
-  return registries[category].has(type);
-}
-
-// Plugin name must be a scoped npm package or a tagma-prefixed package.
-// Reject absolute/relative paths and suspicious patterns to prevent
-// arbitrary code execution via crafted YAML configs.
-export const PLUGIN_NAME_RE = /^(@[a-z0-9-]+\/[a-z0-9._-]+|tagma-plugin-[a-z0-9._-]+)$/;
-
-export function isValidPluginName(name: unknown): name is string {
-  return typeof name === 'string' && PLUGIN_NAME_RE.test(name);
-}
-
-/**
- * Parse and validate the `tagmaPlugin` field of a `package.json` blob.
- *
- * Returns the strongly-typed manifest if the field is present and
- * well-formed (`category` is one of the four known categories and `type`
- * is a non-empty string). Returns `null` if the field is absent — that
- * is the host's signal that the package is a library, not a plugin.
- *
- * Throws if the field is present but malformed: that's a packaging bug
- * the plugin author should hear about loudly, not a silent skip.
- *
- * Hosts use this during auto-discovery to decide whether to load a
- * package as a plugin without having to dynamically `import()` it.
- */
-export function readPluginManifest(pkgJson: unknown): PluginManifest | null {
-  if (!pkgJson || typeof pkgJson !== 'object') return null;
-  const raw = (pkgJson as Record<string, unknown>).tagmaPlugin;
-  if (raw === undefined) return null;
-  if (!raw || typeof raw !== 'object') {
-    throw new Error('tagmaPlugin field must be an object with { category, type }');
-  }
-  const m = raw as Record<string, unknown>;
-  const category = m.category;
-  const type = m.type;
-  if (typeof category !== 'string' || !VALID_CATEGORIES.has(category as PluginCategory)) {
-    throw new Error(
-      `tagmaPlugin.category must be one of ${[...VALID_CATEGORIES].join(', ')}, got ${JSON.stringify(category)}`
-    );
-  }
-  if (typeof type !== 'string' || type.length === 0) {
-    throw new Error(`tagmaPlugin.type must be a non-empty string, got ${JSON.stringify(type)}`);
-  }
-  return { category: category as PluginCategory, type };
-}
-
-export async function loadPlugins(pluginNames: readonly string[]): Promise<void> {
-  for (const name of pluginNames) {
-    if (!isValidPluginName(name)) {
-      throw new Error(
-        `Plugin "${name}" rejected: plugin names must be scoped npm packages ` +
-        `(e.g. @tagma/trigger-xyz) or tagma-plugin-* packages. ` +
-        `Relative/absolute paths are not allowed.`
-      );
-    }
-    const mod = await import(name);
-    if (!mod.pluginCategory || !mod.pluginType || !mod.default) {
-      throw new Error(
-        `Plugin "${name}" must export pluginCategory, pluginType, and default`
-      );
-    }
-    registerPlugin(mod.pluginCategory, mod.pluginType, mod.default);
-  }
-}
-
-export function listRegistered(category: PluginCategory): string[] {
-  return [...registries[category].keys()];
-}
+import type {
+  PluginCategory, DriverPlugin, TriggerPlugin,
+  CompletionPlugin, MiddlewarePlugin, PluginManifest,
+} from './types';
+
+type PluginType = DriverPlugin | TriggerPlugin | CompletionPlugin | MiddlewarePlugin;
+
+const VALID_CATEGORIES: ReadonlySet<PluginCategory> = new Set([
+  'drivers', 'triggers', 'completions', 'middlewares',
+]);
+
+const registries = {
+  drivers:     new Map<string, DriverPlugin>(),
+  triggers:    new Map<string, TriggerPlugin>(),
+  completions: new Map<string, CompletionPlugin>(),
+  middlewares: new Map<string, MiddlewarePlugin>(),
+};
+
+/**
+ * Minimal contract enforcement so a malformed plugin fails fast at
+ * registration time rather than crashing the engine mid-run.
+ *
+ * For drivers we materialize `capabilities` and assert each field is a
+ * boolean — otherwise a plugin author can write
+ *     get capabilities() { throw new Error('boom') }
+ * and pass the basic typeof check, then crash preflight when the engine
+ * touches `driver.capabilities.sessionResume`. (R8)
+ */
+function validateContract(category: PluginCategory, handler: unknown): void {
+  if (!handler || typeof handler !== 'object') {
+    throw new Error(`Plugin handler for category "${category}" must be an object`);
+  }
+  const h = handler as Record<string, unknown>;
+  if (typeof h.name !== 'string' || h.name.length === 0) {
+    throw new Error(`Plugin handler for category "${category}" must declare a non-empty "name"`);
+  }
+  switch (category) {
+    case 'drivers': {
+      if (typeof h.buildCommand !== 'function') {
+        throw new Error(`drivers plugin "${h.name}" must export buildCommand()`);
+      }
+      // Materialize capabilities — this triggers any throwing getter NOW
+      // instead of during preflight.
+      let caps: unknown;
+      try {
+        caps = h.capabilities;
+      } catch (err) {
+        throw new Error(
+          `drivers plugin "${h.name}" capabilities accessor threw: ` +
+          (err instanceof Error ? err.message : String(err))
+        );
+      }
+      if (!caps || typeof caps !== 'object') {
+        throw new Error(`drivers plugin "${h.name}" must declare capabilities object`);
+      }
+      const c = caps as Record<string, unknown>;
+      for (const field of ['sessionResume', 'systemPrompt', 'outputFormat'] as const) {
+        if (typeof c[field] !== 'boolean') {
+          throw new Error(
+            `drivers plugin "${h.name}".capabilities.${field} must be a boolean (got ${typeof c[field]})`
+          );
+        }
+      }
+      // Optional methods, but if present must be functions.
+      for (const opt of ['parseResult', 'resolveModel', 'resolveTools'] as const) {
+        if (h[opt] !== undefined && typeof h[opt] !== 'function') {
+          throw new Error(
+            `drivers plugin "${h.name}".${opt} must be a function or undefined`
+          );
+        }
+      }
+      break;
+    }
+    case 'triggers':
+      if (typeof h.watch !== 'function') {
+        throw new Error(`triggers plugin "${h.name}" must export watch()`);
+      }
+      break;
+    case 'completions':
+      if (typeof h.check !== 'function') {
+        throw new Error(`completions plugin "${h.name}" must export check()`);
+      }
+      break;
+    case 'middlewares':
+      if (typeof h.enhance !== 'function') {
+        throw new Error(`middlewares plugin "${h.name}" must export enhance()`);
+      }
+      break;
+  }
+}
+
+export type RegisterResult = 'registered' | 'replaced' | 'unchanged';
+
+/**
+ * Register a plugin under (category, type). Returns:
+ *   - 'registered' on first registration
+ *   - 'replaced'   when an existing entry was overwritten with a different handler
+ *   - 'unchanged'  when the same handler instance was already present
+ *
+ * Throws if `category` is unknown, `type` is empty, or `handler` violates the
+ * minimum interface contract for the category.
+ */
+export function registerPlugin<T extends PluginType>(
+  category: PluginCategory, type: string, handler: T,
+): RegisterResult {
+  if (!VALID_CATEGORIES.has(category)) {
+    throw new Error(`Unknown plugin category "${category}"`);
+  }
+  if (typeof type !== 'string' || type.length === 0) {
+    throw new Error(`Plugin type must be a non-empty string (category="${category}")`);
+  }
+  validateContract(category, handler);
+  const registry = registries[category] as Map<string, T>;
+  const existing = registry.get(type);
+  if (existing === handler) return 'unchanged';
+  const wasReplaced = existing !== undefined;
+  registry.set(type, handler);
+  return wasReplaced ? 'replaced' : 'registered';
+}
+
+/**
+ * Remove a plugin from the in-process registry. Returns true if a plugin
+ * was actually removed. Note: ESM module caching is not affected, so
+ * re-importing the same file after unregister will yield the cached module —
+ * callers wanting a fresh load must restart the host process.
+ */
+export function unregisterPlugin(category: PluginCategory, type: string): boolean {
+  if (!VALID_CATEGORIES.has(category)) return false;
+  return registries[category].delete(type);
+}
+
+export function getHandler<T extends PluginType>(
+  category: PluginCategory, type: string,
+): T {
+  const handler = registries[category].get(type);
+  if (!handler) {
+    throw new Error(
+      `${category} type "${type}" not registered.\n` +
+      `Install the plugin: bun add @tagma/${category.replace(/s$/, '')}-${type}`
+    );
+  }
+  return handler as T;
+}
+
+export function hasHandler(category: PluginCategory, type: string): boolean {
+  return registries[category].has(type);
+}
+
+// Plugin name must be a scoped npm package or a tagma-prefixed package.
+// Reject absolute/relative paths and suspicious patterns to prevent
+// arbitrary code execution via crafted YAML configs.
+export const PLUGIN_NAME_RE = /^(@[a-z0-9-]+\/[a-z0-9._-]+|tagma-plugin-[a-z0-9._-]+)$/;
+
+export function isValidPluginName(name: unknown): name is string {
+  return typeof name === 'string' && PLUGIN_NAME_RE.test(name);
+}
+
+/**
+ * Parse and validate the `tagmaPlugin` field of a `package.json` blob.
+ *
+ * Returns the strongly-typed manifest if the field is present and
+ * well-formed (`category` is one of the four known categories and `type`
+ * is a non-empty string). Returns `null` if the field is absent — that
+ * is the host's signal that the package is a library, not a plugin.
+ *
+ * Throws if the field is present but malformed: that's a packaging bug
+ * the plugin author should hear about loudly, not a silent skip.
+ *
+ * Hosts use this during auto-discovery to decide whether to load a
+ * package as a plugin without having to dynamically `import()` it.
+ */
+export function readPluginManifest(pkgJson: unknown): PluginManifest | null {
+  if (!pkgJson || typeof pkgJson !== 'object') return null;
+  const raw = (pkgJson as Record<string, unknown>).tagmaPlugin;
+  if (raw === undefined) return null;
+  if (!raw || typeof raw !== 'object') {
+    throw new Error('tagmaPlugin field must be an object with { category, type }');
+  }
+  const m = raw as Record<string, unknown>;
+  const category = m.category;
+  const type = m.type;
+  if (typeof category !== 'string' || !VALID_CATEGORIES.has(category as PluginCategory)) {
+    throw new Error(
+      `tagmaPlugin.category must be one of ${[...VALID_CATEGORIES].join(', ')}, got ${JSON.stringify(category)}`
+    );
+  }
+  if (typeof type !== 'string' || type.length === 0) {
+    throw new Error(`tagmaPlugin.type must be a non-empty string, got ${JSON.stringify(type)}`);
+  }
+  return { category: category as PluginCategory, type };
+}
+
+export async function loadPlugins(pluginNames: readonly string[]): Promise<void> {
+  for (const name of pluginNames) {
+    if (!isValidPluginName(name)) {
+      throw new Error(
+        `Plugin "${name}" rejected: plugin names must be scoped npm packages ` +
+        `(e.g. @tagma/trigger-xyz) or tagma-plugin-* packages. ` +
+        `Relative/absolute paths are not allowed.`
+      );
+    }
+    const mod = await import(name);
+    if (!mod.pluginCategory || !mod.pluginType || !mod.default) {
+      throw new Error(
+        `Plugin "${name}" must export pluginCategory, pluginType, and default`
+      );
+    }
+    registerPlugin(mod.pluginCategory, mod.pluginType, mod.default);
+  }
+}
+
+export function listRegistered(category: PluginCategory): string[] {
+  return [...registries[category].keys()];
+}

package/src/schema.ts

@@ -264,8 +264,9 @@ export function resolveConfig(raw: RawPipelineConfig, workDir: string): Pipeline
           ? qualifyContinueFrom(rawTask.continue_from, rawTrack.id)
           : undefined,
         output: rawTask.output,
-        // Inheritance: Task > Track
-        model_tier: rawTask.model_tier ?? rawTrack.model_tier ?? 'medium',
+        // Inheritance: Task > Track > Pipeline
+        model: rawTask.model ?? rawTrack.model ?? raw.model,
+        reasoning_effort: rawTask.reasoning_effort ?? rawTrack.reasoning_effort ?? raw.reasoning_effort,
         permissions: rawTask.permissions ?? rawTrack.permissions ?? DEFAULT_PERMISSIONS,
         driver: rawTask.driver ?? trackDriver ?? 'claude-code',
         timeout: rawTask.timeout,
@@ -282,7 +283,8 @@ export function resolveConfig(raw: RawPipelineConfig, workDir: string): Pipeline
       name: rawTrack.name,
       color: rawTrack.color,
       agent_profile: rawTrack.agent_profile,
-      model_tier: rawTrack.model_tier ?? 'medium',
+      model: rawTrack.model ?? raw.model,
+      reasoning_effort: rawTrack.reasoning_effort ?? raw.reasoning_effort,
       permissions: rawTrack.permissions ?? DEFAULT_PERMISSIONS,
       driver: trackDriver ?? 'claude-code',
       cwd: trackCwd,
@@ -295,6 +297,8 @@ export function resolveConfig(raw: RawPipelineConfig, workDir: string): Pipeline
   return {
     name: raw.name,
     driver: raw.driver,
+    model: raw.model,
+    reasoning_effort: raw.reasoning_effort,
     timeout: raw.timeout,
     plugins: raw.plugins,
     hooks: raw.hooks,
@@ -334,6 +338,8 @@ export function deresolvePipeline(config: PipelineConfig, workDir: string): RawP
       ? relative(workDir, track.cwd)
       : undefined;
     const effectiveTrackDriver = track.driver ?? config.driver ?? 'claude-code';
+    const effectiveTrackModel = track.model ?? config.model;
+    const effectiveTrackReasoning = track.reasoning_effort ?? config.reasoning_effort;
 
     const tasks: RawTaskConfig[] = track.tasks.map(task => {
       const taskCwdRel = task.cwd && task.cwd !== track.cwd
@@ -350,7 +356,10 @@ export function deresolvePipeline(config: PipelineConfig, workDir: string): RawP
         ...(task.continue_from ? { continue_from: task.continue_from } : {}),
         ...(task.output ? { output: task.output } : {}),
         ...(taskCwdRel ? { cwd: taskCwdRel } : {}),
-        ...(task.model_tier && task.model_tier !== 'medium' ? { model_tier: task.model_tier } : {}),
+        ...(task.model && task.model !== effectiveTrackModel ? { model: task.model } : {}),
+        ...(task.reasoning_effort && task.reasoning_effort !== effectiveTrackReasoning
+          ? { reasoning_effort: task.reasoning_effort }
+          : {}),
         ...(task.driver && task.driver !== effectiveTrackDriver ? { driver: task.driver } : {}),
         ...(task.timeout ? { timeout: task.timeout } : {}),
         ...(task.middlewares !== undefined ? { middlewares: task.middlewares } : {}),
@@ -367,7 +376,10 @@ export function deresolvePipeline(config: PipelineConfig, workDir: string): RawP
       name: track.name,
       ...(track.color ? { color: track.color } : {}),
       ...(track.agent_profile ? { agent_profile: track.agent_profile } : {}),
-      ...(track.model_tier && track.model_tier !== 'medium' ? { model_tier: track.model_tier } : {}),
+      ...(track.model && track.model !== config.model ? { model: track.model } : {}),
+      ...(track.reasoning_effort && track.reasoning_effort !== config.reasoning_effort
+        ? { reasoning_effort: track.reasoning_effort }
+        : {}),
       ...(track.driver && track.driver !== (config.driver ?? 'claude-code') ? { driver: track.driver } : {}),
       ...(trackCwdRel ? { cwd: trackCwdRel } : {}),
       ...(track.middlewares?.length ? { middlewares: track.middlewares } : {}),
@@ -382,6 +394,8 @@ export function deresolvePipeline(config: PipelineConfig, workDir: string): RawP
   return {
     name: config.name,
     ...(config.driver ? { driver: config.driver } : {}),
+    ...(config.model ? { model: config.model } : {}),
+    ...(config.reasoning_effort ? { reasoning_effort: config.reasoning_effort } : {}),
     ...(config.timeout ? { timeout: config.timeout } : {}),
     ...(config.plugins?.length ? { plugins: config.plugins } : {}),
     ...(config.hooks ? { hooks: config.hooks } : {}),

package/src/validate-raw.ts

@@ -14,7 +14,32 @@ function isValidDuration(input: string): boolean {
 }
 
 const VALID_ON_FAILURE = new Set(['skip_downstream', 'stop_all', 'ignore']);
-const VALID_MODEL_TIERS = new Set(['low', 'medium', 'high']);
+const VALID_REASONING_EFFORT = new Set(['low', 'medium', 'high']);
+
+// Built-in plugin types always known to the SDK core, regardless of which
+// external plugin packages are installed. These MUST stay in sync with the
+// types that `bootstrapBuiltins()` registers, otherwise the editor will
+// emit false-positive "unknown type" warnings for stock pipelines.
+const BUILTIN_TRIGGER_TYPES: ReadonlySet<string> = new Set(['manual', 'file']);
+const BUILTIN_COMPLETION_TYPES: ReadonlySet<string> = new Set([
+  'exit_code', 'file_exists', 'output_check',
+]);
+const BUILTIN_MIDDLEWARE_TYPES: ReadonlySet<string> = new Set(['static_context']);
+
+/**
+ * Optional second argument to `validateRaw`: the set of plugin types currently
+ * registered in the SDK runtime, keyed by category. Hosts (e.g. the editor
+ * server) pass this so `validateRaw` can emit a soft warning when a task
+ * references a type that isn't loaded — otherwise the Task panel would show
+ * no hint and the pipeline would only blow up at run time. Callers that
+ * legitimately validate a config offline (before plugins are loaded) can omit
+ * this argument and no plugin warnings will be produced.
+ */
+export interface KnownPluginTypes {
+  readonly triggers?: readonly string[];
+  readonly completions?: readonly string[];
+  readonly middlewares?: readonly string[];
+}
 
 export type ValidationSeverity = 'error' | 'warning';
 
@@ -38,16 +63,36 @@ export interface ValidationError {
  * Checks structure, required fields, prompt/command exclusivity,
  * depends_on reference integrity, and circular dependencies.
  *
- * Does NOT check plugin registration — plugins may not be loaded yet
- * when the frontend is editing a config offline.
+ * Plugin type checks: when `knownTypes` is provided, task/track references to
+ * trigger/completion/middleware types that are neither built-in nor in the
+ * supplied set produce a soft warning (severity: 'warning') — these don't
+ * block save/run but light up the Task panel so users discover the broken
+ * reference in the editor instead of at run time. Omit `knownTypes` to skip
+ * plugin checks entirely (offline/pre-load validation).
  */
-export function validateRaw(config: RawPipelineConfig): ValidationError[] {
+export function validateRaw(
+  config: RawPipelineConfig,
+  knownTypes?: KnownPluginTypes,
+): ValidationError[] {
   const errors: ValidationError[] = [];
 
+  const knownTriggers = knownTypes
+    ? new Set<string>([...BUILTIN_TRIGGER_TYPES, ...(knownTypes.triggers ?? [])])
+    : null;
+  const knownCompletions = knownTypes
+    ? new Set<string>([...BUILTIN_COMPLETION_TYPES, ...(knownTypes.completions ?? [])])
+    : null;
+  const knownMiddlewares = knownTypes
+    ? new Set<string>([...BUILTIN_MIDDLEWARE_TYPES, ...(knownTypes.middlewares ?? [])])
+    : null;
+
   // ── Top level ──
   if (!config.name?.trim()) {
     errors.push({ path: 'name', message: 'Pipeline name is required' });
   }
+  if (config.reasoning_effort && !VALID_REASONING_EFFORT.has(config.reasoning_effort)) {
+    errors.push({ path: 'reasoning_effort', message: `Invalid reasoning_effort "${config.reasoning_effort}". Expected "low", "medium", or "high".` });
+  }
 
   if (!config.tracks || config.tracks.length === 0) {
     errors.push({ path: 'tracks', message: 'At least one track is required' });
@@ -94,8 +139,24 @@ export function validateRaw(config: RawPipelineConfig): ValidationError[] {
     if (track.on_failure && !VALID_ON_FAILURE.has(track.on_failure)) {
       errors.push({ path: `${trackPath}.on_failure`, message: `Invalid on_failure value "${track.on_failure}". Expected "skip_downstream", "stop_all", or "ignore".` });
     }
-    if (track.model_tier && !VALID_MODEL_TIERS.has(track.model_tier)) {
-      errors.push({ path: `${trackPath}.model_tier`, message: `Invalid model_tier "${track.model_tier}". Expected "low", "medium", or "high".` });
+    if (track.reasoning_effort && !VALID_REASONING_EFFORT.has(track.reasoning_effort)) {
+      errors.push({ path: `${trackPath}.reasoning_effort`, message: `Invalid reasoning_effort "${track.reasoning_effort}". Expected "low", "medium", or "high".` });
+    }
+
+    // Track-level middlewares can reference a plugin that was uninstalled
+    // after the YAML was written — surface a warning so the user notices
+    // before hitting Run.
+    if (knownMiddlewares && track.middlewares) {
+      for (let mi = 0; mi < track.middlewares.length; mi++) {
+        const mw = track.middlewares[mi];
+        if (mw?.type && !knownMiddlewares.has(mw.type)) {
+          errors.push({
+            path: `${trackPath}.middlewares[${mi}].type`,
+            message: `Middleware type "${mw.type}" is not registered. Install the plugin (e.g. @tagma/middleware-${mw.type}) or remove the reference — the pipeline will fail at run time.`,
+            severity: 'warning',
+          });
+        }
+      }
     }
 
     if (!track.tasks || track.tasks.length === 0) {
@@ -153,8 +214,39 @@ export function validateRaw(config: RawPipelineConfig): ValidationError[] {
       if (task.timeout && !isValidDuration(task.timeout)) {
         errors.push({ path: `${taskPath}.timeout`, message: `Invalid duration format "${task.timeout}". Expected e.g. "30s", "5m", "1h".` });
       }
-      if (task.model_tier && !VALID_MODEL_TIERS.has(task.model_tier)) {
-        errors.push({ path: `${taskPath}.model_tier`, message: `Invalid model_tier "${task.model_tier}". Expected "low", "medium", or "high".` });
+      if (task.reasoning_effort && !VALID_REASONING_EFFORT.has(task.reasoning_effort)) {
+        errors.push({ path: `${taskPath}.reasoning_effort`, message: `Invalid reasoning_effort "${task.reasoning_effort}". Expected "low", "medium", or "high".` });
+      }
+
+      // ── Plugin type warnings (trigger / completion / middlewares) ──
+      // Only fire when the host supplied a `knownTypes` snapshot, so offline
+      // validation stays quiet. The messages deliberately name the npm
+      // scope so users can copy-paste the install command.
+      if (knownTriggers && task.trigger?.type && !knownTriggers.has(task.trigger.type)) {
+        errors.push({
+          path: `${taskPath}.trigger.type`,
+          message: `Trigger type "${task.trigger.type}" is not registered. Install the plugin (e.g. @tagma/trigger-${task.trigger.type}) or the task will fail at run time.`,
+          severity: 'warning',
+        });
+      }
+      if (knownCompletions && task.completion?.type && !knownCompletions.has(task.completion.type)) {
+        errors.push({
+          path: `${taskPath}.completion.type`,
+          message: `Completion type "${task.completion.type}" is not registered. Install the plugin (e.g. @tagma/completion-${task.completion.type}) or the task will fail at run time.`,
+          severity: 'warning',
+        });
+      }
+      if (knownMiddlewares && task.middlewares) {
+        for (let mi = 0; mi < task.middlewares.length; mi++) {
+          const mw = task.middlewares[mi];
+          if (mw?.type && !knownMiddlewares.has(mw.type)) {
+            errors.push({
+              path: `${taskPath}.middlewares[${mi}].type`,
+              message: `Middleware type "${mw.type}" is not registered. Install the plugin (e.g. @tagma/middleware-${mw.type}) or remove the reference — the pipeline will fail at run time.`,
+              severity: 'warning',
+            });
+          }
+        }
       }
 
       // ── depends_on reference checks ──