@laitszkin/apollo-toolkit 3.13.2 → 3.14.1

package/lib/tools/search-logs.ts

@@ -0,0 +1,200 @@
+// @ts-nocheck
+import type { ToolContext } from '../types';
+import {
+  extractTimestamp,
+  inWindow,
+  iterInputLines,
+  parseCliTimestamp,
+  buildTimezone,
+  validateTimeWindow,
+} from './log-cli-utils';
+
+interface SearchLogsArgs {
+  paths: string[];
+  keyword: string[];
+  regex: string[];
+  mode: 'any' | 'all';
+  ignoreCase: boolean;
+  start: string | null;
+  end: string | null;
+  assumeTimezone: string;
+  beforeContext: number;
+  afterContext: number;
+  countOnly: boolean;
+}
+
+function parseArgs(argv: string[]): SearchLogsArgs {
+  const args: SearchLogsArgs = {
+    paths: [],
+    keyword: [],
+    regex: [],
+    mode: 'any',
+    ignoreCase: false,
+    start: null,
+    end: null,
+    assumeTimezone: 'UTC',
+    beforeContext: 0,
+    afterContext: 0,
+    countOnly: false,
+  };
+
+  let i = 0;
+  while (i < argv.length) {
+    const arg = argv[i];
+    if (arg === '--keyword' && i + 1 < argv.length) {
+      args.keyword.push(argv[++i]);
+    } else if (arg === '--regex' && i + 1 < argv.length) {
+      args.regex.push(argv[++i]);
+    } else if (arg === '--mode' && i + 1 < argv.length) {
+      const val = argv[++i];
+      if (val === 'any' || val === 'all') {
+        args.mode = val;
+      }
+    } else if (arg === '--ignore-case') {
+      args.ignoreCase = true;
+    } else if (arg === '--start' && i + 1 < argv.length) {
+      args.start = argv[++i];
+    } else if (arg === '--end' && i + 1 < argv.length) {
+      args.end = argv[++i];
+    } else if (arg === '--assume-timezone' && i + 1 < argv.length) {
+      args.assumeTimezone = argv[++i];
+    } else if (arg === '--before-context' && i + 1 < argv.length) {
+      args.beforeContext = parseInt(argv[++i], 10) || 0;
+    } else if (arg === '--after-context' && i + 1 < argv.length) {
+      args.afterContext = parseInt(argv[++i], 10) || 0;
+    } else if (arg === '--count-only') {
+      args.countOnly = true;
+    } else if (arg.startsWith('-')) {
+      // skip unknown flags
+    } else {
+      args.paths.push(arg);
+    }
+    i++;
+  }
+
+  return args;
+}
+
+interface Matcher {
+  (line: string): boolean;
+}
+
+function buildMatchers(args: SearchLogsArgs): Matcher[] {
+  const matchers: Matcher[] = [];
+
+  for (const keyword of args.keyword) {
+    const needle = args.ignoreCase ? keyword.toLowerCase() : keyword;
+    matchers.push((line: string) => {
+      const haystack = args.ignoreCase ? line.toLowerCase() : line;
+      return haystack.includes(needle);
+    });
+  }
+
+  for (const pattern of args.regex) {
+    const flags = args.ignoreCase ? 'i' : '';
+    const compiled = new RegExp(pattern, flags);
+    matchers.push((line: string) => compiled.test(line));
+  }
+
+  return matchers;
+}
+
+function lineMatches(
+  line: string,
+  matchers: Matcher[],
+  mode: 'any' | 'all',
+): boolean {
+  if (matchers.length === 0) return true;
+  if (mode === 'any') {
+    return matchers.some((m) => m(line));
+  }
+  return matchers.every((m) => m(line));
+}
+
+export async function searchLogsHandler(
+  argv: string[],
+  context: ToolContext,
+): Promise<number> {
+  const { stdout, stderr } = context;
+  const args = parseArgs(argv);
+
+  try {
+    buildTimezone(args.assumeTimezone);
+  } catch (err) {
+    stderr.write(`Error: invalid timezone: ${args.assumeTimezone}\n`);
+    return 1;
+  }
+
+  let start: Date | null = null;
+  let end: Date | null = null;
+
+  try {
+    if (args.start) {
+      start = parseCliTimestamp(args.start, args.assumeTimezone);
+    }
+    if (args.end) {
+      end = parseCliTimestamp(args.end, args.assumeTimezone);
+    }
+  } catch (err) {
+    stderr.write(`Error: ${(err as Error).message}\n`);
+    return 1;
+  }
+
+  if (!validateTimeWindow(start, end, stderr)) {
+    return 1;
+  }
+
+  const matchers = buildMatchers(args);
+  let matches = 0;
+  const beforeBuffer: string[] = [];
+  let afterRemaining = 0;
+
+  try {
+    for await (const line of iterInputLines(args.paths)) {
+      const timestamp = extractTimestamp(line, args.assumeTimezone);
+
+      // When time filter is active, skip lines outside the window
+      if (args.start || args.end) {
+        if (!inWindow(timestamp, start, end)) {
+          beforeBuffer.push(line);
+          if (beforeBuffer.length > args.beforeContext) {
+            beforeBuffer.shift();
+          }
+          continue;
+        }
+      }
+
+      const isMatch = lineMatches(line, matchers, args.mode);
+
+      if (isMatch) {
+        matches++;
+        if (!args.countOnly) {
+          // Flush before context
+          for (const ctxLine of beforeBuffer) {
+            stdout.write(ctxLine + '\n');
+          }
+          stdout.write(line + '\n');
+        }
+        afterRemaining = args.afterContext;
+      } else if (afterRemaining > 0 && !args.countOnly) {
+        stdout.write(line + '\n');
+        afterRemaining--;
+      }
+
+      // Maintain before context buffer
+      beforeBuffer.push(line);
+      if (beforeBuffer.length > args.beforeContext) {
+        beforeBuffer.shift();
+      }
+    }
+  } catch (err) {
+    stderr.write(`Error: ${(err as Error).message}\n`);
+    return 1;
+  }
+
+  if (args.countOnly) {
+    stdout.write(String(matches) + '\n');
+  }
+
+  return 0;
+}

package/lib/tools/sync-memory-index.ts

@@ -0,0 +1,114 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import type { ToolContext } from '../types';
+
+const START_MARKER = '<!-- codex-memory-manager:start -->';
+const END_MARKER = '<!-- codex-memory-manager:end -->';
+const DEFAULT_SECTION_TITLE = '## User Memory Index';
+const DEFAULT_INSTRUCTIONS = [
+  'Before starting work, review the index below and open any relevant user preference files.',
+  'When a new preference category appears, create or update the matching memory file and refresh this index.',
+];
+
+function titleFromMemoryFile(filePath: string): string {
+  try {
+    const content = fs.readFileSync(filePath, 'utf8');
+    for (const line of content.split('\n')) {
+      const stripped = line.trim();
+      if (stripped.startsWith('# ')) {
+        return stripped.slice(2).trim() || path.basename(filePath).replace(/\.md$/, '').replace(/-/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase());
+      }
+    }
+  } catch {
+    // fall through
+  }
+  return path.basename(filePath).replace(/\.md$/, '').replace(/-/g, ' ').replace(/\b\w/g, (c) => c.toUpperCase());
+}
+
+function iterMemoryFiles(memoryDir: string): string[] {
+  if (!fs.existsSync(memoryDir)) return [];
+  const entries = fs.readdirSync(memoryDir);
+  return entries
+    .filter((name) => name.endsWith('.md'))
+    .map((name) => path.join(memoryDir, name))
+    .filter((p) => fs.statSync(p).isFile())
+    .sort((a, b) => path.basename(a).toLowerCase().localeCompare(path.basename(b).toLowerCase()));
+}
+
+function renderSection(memoryFiles: string[], sectionTitle: string, instructionLines: string[]): string {
+  const lines = [START_MARKER, sectionTitle.trim(), ''];
+
+  const cleaned = instructionLines.filter((line) => line && line.trim());
+  for (const line of cleaned) {
+    lines.push(line.trim());
+  }
+  if (cleaned.length) lines.push('');
+
+  if (memoryFiles.length) {
+    const entries = memoryFiles
+      .map((p) => ({ title: titleFromMemoryFile(p), resolved: path.resolve(p) }))
+      .sort((a, b) => a.title.toLowerCase().localeCompare(b.title.toLowerCase()) || a.resolved.localeCompare(b.resolved));
+    for (const { title, resolved } of entries) {
+      lines.push(`- [${title}](file://${resolved})`);
+    }
+  } else {
+    lines.push('- No memory files are currently indexed.');
+  }
+
+  lines.push(END_MARKER);
+  return lines.join('\n');
+}
+
+function removeExistingSection(content: string): string {
+  const pattern = new RegExp(`\n*${escapeRegex(START_MARKER)}[\\s\\S]*?${escapeRegex(END_MARKER)}\n*`, 'g');
+  return content.replace(pattern, '\n\n').trimEnd();
+}
+
+function escapeRegex(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+
+function syncAgentsFile(agentsFile: string, sectionText: string): void {
+  const dir = path.dirname(agentsFile);
+  fs.mkdirSync(dir, { recursive: true });
+
+  let original = '';
+  try {
+    original = fs.readFileSync(agentsFile, 'utf8');
+  } catch {
+    // file doesn't exist
+  }
+
+  const base = removeExistingSection(original);
+  const updated = base ? `${base}\n\n${sectionText}\n` : `${sectionText}\n`;
+  fs.writeFileSync(agentsFile, updated, 'utf8');
+}
+
+export function syncMemoryIndexHandler(args: string[], context: ToolContext): Promise<number> {
+  try {
+    const homeDir = process.env.HOME || '';
+    let agentsFile = path.join(homeDir, '.codex', 'AGENTS.md');
+    let memoryDir = path.join(homeDir, '.codex', 'memory');
+    let sectionTitle = DEFAULT_SECTION_TITLE;
+    let instructionLines = [...DEFAULT_INSTRUCTIONS];
+
+    for (let i = 0; i < args.length; i++) {
+      if (args[i] === '--agents-file' && i + 1 < args.length) agentsFile = args[++i];
+      else if (args[i] === '--memory-dir' && i + 1 < args.length) memoryDir = args[++i];
+      else if (args[i] === '--section-title' && i + 1 < args.length) sectionTitle = args[++i];
+      else if (args[i] === '--instruction-line' && i + 1 < args.length) instructionLines.push(args[++i]);
+    }
+
+    const memoryFiles = iterMemoryFiles(memoryDir);
+    const sectionText = renderSection(memoryFiles, sectionTitle, instructionLines);
+    syncAgentsFile(agentsFile, sectionText);
+
+    context.stdout?.write(`SYNCED_AGENTS_FILE=${path.resolve(agentsFile)}\n`);
+    context.stdout?.write(`MEMORY_FILES_INDEXED=${memoryFiles.length}\n`);
+    return Promise.resolve(0);
+  } catch (err) {
+    const stderr = context.stderr || process.stderr;
+    stderr.write(`Error: ${(err as Error).message}\n`);
+    return Promise.resolve(1);
+  }
+}

package/lib/tools/validate-openai-agent-config.ts

@@ -0,0 +1,213 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import yaml from 'js-yaml';
+import type { ToolContext } from '../types';
+
+const TOP_LEVEL_ALLOWED_KEYS = new Set(['interface', 'dependencies', 'policy']);
+const INTERFACE_REQUIRED_KEYS = new Set(['display_name', 'short_description', 'default_prompt']);
+const INTERFACE_ALLOWED_KEYS = new Set([
+  'display_name', 'short_description', 'default_prompt',
+  'icon_small', 'icon_large', 'brand_color',
+]);
+const HEX_COLOR_PATTERN = /^#[0-9A-Fa-f]{6}$/;
+
+function repoRoot(context?: ToolContext): string {
+  if (context?.sourceRoot) return context.sourceRoot;
+  // __dirname is dist/lib/tools/; need to go up 3 levels to project root
+  const fromDirname = path.resolve(__dirname, '..', '..', '..');
+  if (fs.existsSync(path.join(fromDirname, 'package.json'))) return fromDirname;
+  return path.resolve(__dirname, '..', '..', '..');
+}
+
+function iterSkillDirs(root: string): string[] {
+  return fs.readdirSync(root)
+    .filter((name) => {
+      const full = path.join(root, name);
+      return fs.statSync(full).isDirectory() && fs.existsSync(path.join(full, 'SKILL.md'));
+    })
+    .map((name) => path.join(root, name))
+    .sort();
+}
+
+function extractFrontmatter(content: string): Record<string, any> {
+  const lines = content.split('\n');
+  if (!lines.length || lines[0].trim() !== '---') {
+    throw new Error("SKILL.md must start with YAML frontmatter delimiter '---'.");
+  }
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i].trim() === '---') {
+      const raw = lines.slice(1, i).join('\n');
+      const parsed = yaml.load(raw);
+      if (typeof parsed !== 'object' || parsed === null) {
+        throw new Error('SKILL.md frontmatter must be a YAML mapping.');
+      }
+      return parsed as Record<string, any>;
+    }
+  }
+  throw new Error("SKILL.md frontmatter is missing the closing '---' delimiter.");
+}
+
+function requireNonEmptyString(container: Record<string, any>, key: string, context: string, errors: string[]): void {
+  const value = container[key];
+  if (typeof value !== 'string' || !value.trim()) {
+    errors.push(`${context}: '${key}' must be a non-empty string.`);
+  }
+}
+
+function validateDependencies(dependencies: any, context: string, errors: string[]): void {
+  if (typeof dependencies !== 'object' || dependencies === null) {
+    errors.push(`${context}: 'dependencies' must be a mapping.`);
+    return;
+  }
+
+  const tools = dependencies['tools'];
+  if (tools === undefined) return;
+  if (!Array.isArray(tools)) {
+    errors.push(`${context}: 'dependencies.tools' must be a list.`);
+    return;
+  }
+
+  for (let i = 0; i < tools.length; i++) {
+    const itemContext = `${context}: dependencies.tools[${i}]`;
+    const item = tools[i];
+    if (typeof item !== 'object' || item === null) {
+      errors.push(`${itemContext} must be a mapping.`);
+      continue;
+    }
+    requireNonEmptyString(item, 'type', itemContext, errors);
+    requireNonEmptyString(item, 'value', itemContext, errors);
+
+    if (typeof item['type'] === 'string' && item['type'] !== 'mcp') {
+      errors.push(`${itemContext}: unsupported tool type '${item['type']}', only 'mcp' is allowed.`);
+    }
+
+    for (const optionalKey of ['description', 'transport', 'url']) {
+      const optionalValue = item[optionalKey];
+      if (optionalValue !== undefined && (typeof optionalValue !== 'string' || !optionalValue.trim())) {
+        errors.push(`${itemContext}: '${optionalKey}' must be a non-empty string when provided.`);
+      }
+    }
+  }
+}
+
+function validatePolicy(policy: any, context: string, errors: string[]): void {
+  if (typeof policy !== 'object' || policy === null) {
+    errors.push(`${context}: 'policy' must be a mapping.`);
+    return;
+  }
+
+  const allowImplicit = policy['allow_implicit_invocation'];
+  if (allowImplicit !== undefined && typeof allowImplicit !== 'boolean') {
+    errors.push(`${context}: 'policy.allow_implicit_invocation' must be a boolean when provided.`);
+  }
+}
+
+function validateSkill(skillDir: string): string[] {
+  const errors: string[] = [];
+  const skillMd = path.join(skillDir, 'SKILL.md');
+  const openaiYaml = path.join(skillDir, 'agents', 'openai.yaml');
+
+  let skillFrontmatter: Record<string, any>;
+  try {
+    skillFrontmatter = extractFrontmatter(fs.readFileSync(skillMd, 'utf8'));
+  } catch (exc: any) {
+    return [`${skillMd}: unable to read skill name for validation (${exc.message}).`];
+  }
+
+  const skillName = skillFrontmatter['name'];
+  if (typeof skillName !== 'string' || !skillName.trim()) {
+    return [`${skillMd}: frontmatter 'name' must be a non-empty string.`];
+  }
+
+  if (!fs.existsSync(openaiYaml)) {
+    return [`${openaiYaml}: file is required for every skill.`];
+  }
+
+  let parsed: any;
+  try {
+    parsed = yaml.load(fs.readFileSync(openaiYaml, 'utf8'));
+  } catch (exc: any) {
+    return [`${openaiYaml}: invalid YAML (${exc.message}).`];
+  }
+
+  if (typeof parsed !== 'object' || parsed === null) {
+    return [`${openaiYaml}: top-level structure must be a YAML mapping.`];
+  }
+
+  const topLevelKeys = new Set(Object.keys(parsed));
+  const unsupportedTopKeys = [...topLevelKeys].filter((k) => !TOP_LEVEL_ALLOWED_KEYS.has(k)).sort();
+  if (unsupportedTopKeys.length) {
+    errors.push(`${openaiYaml}: unsupported top-level keys: ${unsupportedTopKeys.join(', ')}.`);
+  }
+
+  const iface = parsed['interface'];
+  if (typeof iface !== 'object' || iface === null) {
+    errors.push(`${openaiYaml}: 'interface' must be a mapping.`);
+    return errors;
+  }
+
+  const missingInterfaceKeys = [...INTERFACE_REQUIRED_KEYS].filter((k) => !(k in iface)).sort();
+  if (missingInterfaceKeys.length) {
+    errors.push(`${openaiYaml}: missing required interface keys: ${missingInterfaceKeys.join(', ')}.`);
+  }
+
+  const unsupportedInterfaceKeys = Object.keys(iface).filter((k) => !INTERFACE_ALLOWED_KEYS.has(k)).sort();
+  if (unsupportedInterfaceKeys.length) {
+    errors.push(`${openaiYaml}: unsupported interface keys: ${unsupportedInterfaceKeys.join(', ')}.`);
+  }
+
+  for (const requiredKey of [...INTERFACE_REQUIRED_KEYS].sort()) {
+    requireNonEmptyString(iface, requiredKey, `${openaiYaml}`, errors);
+  }
+
+  const defaultPrompt = iface['default_prompt'];
+  const expectedSkillRef = `$${skillName.trim()}`;
+  if (typeof defaultPrompt === 'string' && !defaultPrompt.includes(expectedSkillRef)) {
+    errors.push(`${openaiYaml}: interface.default_prompt must reference '${expectedSkillRef}'.`);
+  }
+
+  const brandColor = iface['brand_color'];
+  if (brandColor !== undefined) {
+    if (typeof brandColor !== 'string' || !HEX_COLOR_PATTERN.test(brandColor)) {
+      errors.push(`${openaiYaml}: interface.brand_color must be a hex color like '#1A2B3C'.`);
+    }
+  }
+
+  const dependencies = parsed['dependencies'];
+  if (dependencies !== undefined) {
+    validateDependencies(dependencies, `${openaiYaml}`, errors);
+  }
+
+  const policy = parsed['policy'];
+  if (policy !== undefined) {
+    validatePolicy(policy, `${openaiYaml}`, errors);
+  }
+
+  return errors;
+}
+
+export function validateOpenaiAgentConfigHandler(args: string[], context: ToolContext): Promise<number> {
+  const root = repoRoot(context);
+  const skillDirs = iterSkillDirs(root);
+
+  if (!skillDirs.length) {
+    context.stdout?.write('No top-level skill directories found.\n');
+    return Promise.resolve(1);
+  }
+
+  const allErrors: string[] = [];
+  for (const dir of skillDirs) {
+    allErrors.push(...validateSkill(dir));
+  }
+
+  if (allErrors.length) {
+    context.stdout?.write('agents/openai.yaml validation failed:\n');
+    for (const error of allErrors) {
+      context.stdout?.write(`- ${error}\n`);
+    }
+    return Promise.resolve(1);
+  }
+
+  context.stdout?.write(`agents/openai.yaml validation passed for ${skillDirs.length} skills.\n`);
+  return Promise.resolve(0);
+}

package/lib/tools/validate-skill-frontmatter.ts

@@ -0,0 +1,124 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import type { ToolContext } from '../types';
+
+const NAME_PATTERN = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+const REQUIRED_KEYS = new Set(['name', 'description']);
+const MAX_DESCRIPTION_LENGTH = 1024;
+
+function repoRoot(context?: ToolContext): string {
+  if (context?.sourceRoot) return context.sourceRoot;
+  // __dirname is dist/lib/tools/; need to go up 3 levels to project root
+  const fromDirname = path.resolve(__dirname, '..', '..', '..');
+  if (fs.existsSync(path.join(fromDirname, 'package.json'))) return fromDirname;
+  return path.resolve(__dirname, '..', '..', '..');
+}
+
+function iterSkillDirs(root: string): string[] {
+  return fs.readdirSync(root)
+    .filter((name) => {
+      const full = path.join(root, name);
+      return fs.statSync(full).isDirectory() && fs.existsSync(path.join(full, 'SKILL.md'));
+    })
+    .map((name) => path.join(root, name))
+    .sort();
+}
+
+function extractFrontmatter(content: string): string {
+  const lines = content.split('\n');
+  if (!lines.length || lines[0].trim() !== '---') {
+    throw new Error("SKILL.md must start with YAML frontmatter delimiter '---'.");
+  }
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i].trim() === '---') {
+      return lines.slice(1, i).join('\n');
+    }
+  }
+  throw new Error("SKILL.md frontmatter is missing the closing '---' delimiter.");
+}
+
+function validateSkill(skillDir: string): string[] {
+  const errors: string[] = [];
+  const skillMd = path.join(skillDir, 'SKILL.md');
+
+  let content: string;
+  try {
+    content = fs.readFileSync(skillMd, 'utf8');
+  } catch (exc: any) {
+    return [`${skillMd}: cannot read file (${exc.message}).`];
+  }
+
+  let frontmatterText: string;
+  try {
+    frontmatterText = extractFrontmatter(content);
+  } catch (exc: any) {
+    return [`${skillMd}: ${exc.message}`];
+  }
+
+  // Simple YAML-like parsing for frontmatter (handles the common cases)
+  let frontmatter: Record<string, any> = {};
+  for (const line of frontmatterText.split('\n')) {
+    const match = line.match(/^(\w+):\s*(.*)$/);
+    if (match) {
+      frontmatter[match[1]] = match[2].trim();
+    }
+  }
+
+  const keys = new Set(Object.keys(frontmatter));
+  const missing = [...REQUIRED_KEYS].filter((k) => !keys.has(k));
+  const extra = [...keys].filter((k) => !REQUIRED_KEYS.has(k));
+  if (missing.length) {
+    errors.push(`${skillMd}: missing required frontmatter keys: ${missing.join(', ')}.`);
+  }
+  if (extra.length) {
+    errors.push(`${skillMd}: unsupported frontmatter keys: ${extra.join(', ')}.`);
+  }
+
+  const name = frontmatter['name'];
+  if (typeof name !== 'string' || !name.trim()) {
+    errors.push(`${skillMd}: 'name' must be a non-empty string.`);
+  } else {
+    const normalizedName = name.trim();
+    if (!NAME_PATTERN.test(normalizedName)) {
+      errors.push(`${skillMd}: 'name' must be kebab-case (lowercase letters, digits, and hyphens).`);
+    }
+    if (normalizedName !== path.basename(skillDir)) {
+      errors.push(`${skillMd}: frontmatter name '${normalizedName}' must match folder name '${path.basename(skillDir)}'.`);
+    }
+  }
+
+  const description = frontmatter['description'];
+  if (typeof description !== 'string' || !description.trim()) {
+    errors.push(`${skillMd}: 'description' must be a non-empty string.`);
+  } else if (description.length > MAX_DESCRIPTION_LENGTH) {
+    errors.push(`${skillMd}: invalid description: exceeds maximum length of ${MAX_DESCRIPTION_LENGTH} characters`);
+  }
+
+  return errors;
+}
+
+export function validateSkillFrontmatterHandler(args: string[], context: ToolContext): Promise<number> {
+  const root = repoRoot(context);
+  const skillDirs = iterSkillDirs(root);
+
+  if (!skillDirs.length) {
+    context.stdout?.write('No top-level skill directories found.\n');
+    return Promise.resolve(1);
+  }
+
+  const allErrors: string[] = [];
+  for (const dir of skillDirs) {
+    allErrors.push(...validateSkill(dir));
+  }
+
+  if (allErrors.length) {
+    context.stdout?.write('SKILL.md frontmatter validation failed:\n');
+    for (const error of allErrors) {
+      context.stdout?.write(`- ${error}\n`);
+    }
+    return Promise.resolve(1);
+  }
+
+  context.stdout?.write(`SKILL.md frontmatter validation passed for ${skillDirs.length} skills.\n`);
+  return Promise.resolve(0);
+}