skill-universe 1.1.0

package/build/dev/javascript/skillc/compiler_test.mjs

@@ -0,0 +1,3089 @@
+import * as $list from "../gleam_stdlib/gleam/list.mjs";
+import * as $option from "../gleam_stdlib/gleam/option.mjs";
+import * as $string from "../gleam_stdlib/gleam/string.mjs";
+import * as $should from "../gleeunit/gleeunit/should.mjs";
+import * as $simplifile from "../simplifile/simplifile.mjs";
+import { Ok, Error, toList, Empty as $Empty, makeError, isEqual } from "./gleam.mjs";
+import * as $skillc from "./skillc.mjs";
+import * as $compiler from "./skillc/compiler.mjs";
+import * as $error from "./skillc/error.mjs";
+import * as $parser from "./skillc/parser.mjs";
+import * as $types from "./skillc/types.mjs";
+
+const FILEPATH = "test/compiler_test.gleam";
+
+export function compile_all_providers_test() {
+  let result = $compiler.compile_all("test/fixtures/valid-skill");
+  let compiled_list;
+  if (result instanceof Ok) {
+    compiled_list = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      18,
+      "compile_all_providers_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 490,
+        end: 527,
+        pattern_start: 501,
+        pattern_end: 518
+      }
+    )
+  }
+  let providers = $list.map(compiled_list, (c) => { return c.provider; });
+  $should.be_true($list.contains(providers, new $types.ClaudeCode()));
+  $should.be_true($list.contains(providers, new $types.Codex()));
+  return $should.be_true($list.contains(providers, new $types.OpenClaw()));
+}
+
+export function compile_openclaw_produces_skill_md_test() {
+  let $ = $compiler.compile("test/fixtures/valid-skill", "openclaw");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      26,
+      "compile_openclaw_produces_skill_md_test",
+      "Pattern match failed, no pattern matched the value.",
+      { value: $, start: 824, end: 911, pattern_start: 835, pattern_end: 847 }
+    )
+  }
+  $should.be_true($string.contains(compiled.skill_md, "---"));
+  $should.be_true($string.contains(compiled.skill_md, "name: test-skill"));
+  return $should.be_true(
+    $string.contains(compiled.skill_md, "metadata.openclaw:"),
+  );
+}
+
+export function compile_claude_code_produces_skill_md_test() {
+  let $ = $compiler.compile("test/fixtures/valid-skill", "claude-code");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      34,
+      "compile_claude_code_produces_skill_md_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 1179,
+        end: 1269,
+        pattern_start: 1190,
+        pattern_end: 1202
+      }
+    )
+  }
+  $should.be_true($string.contains(compiled.skill_md, "---"));
+  $should.be_true($string.contains(compiled.skill_md, "name: test-skill"));
+  return $should.be_true(
+    $string.contains(compiled.skill_md, "user-invocable: true"),
+  );
+}
+
+export function compile_codex_produces_skill_md_test() {
+  let $ = $compiler.compile("test/fixtures/valid-skill", "codex");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      42,
+      "compile_codex_produces_skill_md_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 1533,
+        end: 1617,
+        pattern_start: 1544,
+        pattern_end: 1556
+      }
+    )
+  }
+  $should.be_true($string.contains(compiled.skill_md, "---"));
+  return $should.be_true(
+    $string.contains(compiled.skill_md, "name: test-skill"),
+  );
+}
+
+export function compile_single_provider_openclaw_test() {
+  let result = $compiler.compile("test/fixtures/valid-skill", "openclaw");
+  $should.be_ok(result);
+  let compiled;
+  if (result instanceof Ok) {
+    compiled = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      55,
+      "compile_single_provider_openclaw_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 2099,
+        end: 2131,
+        pattern_start: 2110,
+        pattern_end: 2122
+      }
+    )
+  }
+  return $should.equal(compiled.provider, new $types.OpenClaw());
+}
+
+export function compile_single_provider_claude_code_test() {
+  let result = $compiler.compile("test/fixtures/valid-skill", "claude-code");
+  $should.be_ok(result);
+  let compiled;
+  if (result instanceof Ok) {
+    compiled = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      62,
+      "compile_single_provider_claude_code_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 2338,
+        end: 2370,
+        pattern_start: 2349,
+        pattern_end: 2361
+      }
+    )
+  }
+  return $should.equal(compiled.provider, new $types.ClaudeCode());
+}
+
+export function compile_single_provider_codex_test() {
+  let result = $compiler.compile("test/fixtures/valid-skill", "codex");
+  $should.be_ok(result);
+  let compiled;
+  if (result instanceof Ok) {
+    compiled = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      69,
+      "compile_single_provider_codex_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 2567,
+        end: 2599,
+        pattern_start: 2578,
+        pattern_end: 2590
+      }
+    )
+  }
+  return $should.equal(compiled.provider, new $types.Codex());
+}
+
+export function compile_single_target_from_multi_provider_test() {
+  let result = $compiler.compile("test/fixtures/valid-skill", "openclaw");
+  $should.be_ok(result);
+  let compiled;
+  if (result instanceof Ok) {
+    compiled = result[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      81,
+      "compile_single_target_from_multi_provider_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 3070,
+        end: 3102,
+        pattern_start: 3081,
+        pattern_end: 3093
+      }
+    )
+  }
+  return $should.equal(compiled.provider, new $types.OpenClaw());
+}
+
+export function compile_all_returns_all_providers_test() {
+  let $ = $compiler.compile_all("test/fixtures/valid-skill");
+  let compiled_list;
+  if ($ instanceof Ok) {
+    compiled_list = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      86,
+      "compile_all_returns_all_providers_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 3208,
+        end: 3292,
+        pattern_start: 3219,
+        pattern_end: 3236
+      }
+    )
+  }
+  return $should.equal($list.length(compiled_list), 3);
+}
+
+export function openclaw_metadata_merging_test() {
+  let $ = $compiler.compile("test/fixtures/valid-skill", "openclaw");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      96,
+      "openclaw_metadata_merging_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 3573,
+        end: 3660,
+        pattern_start: 3584,
+        pattern_end: 3596
+      }
+    )
+  }
+  $should.be_true($string.contains(compiled.skill_md, "name: test-skill"));
+  $should.be_true(
+    $string.contains(
+      compiled.skill_md,
+      "description: \"A test skill for validation\"",
+    ),
+  );
+  return $should.be_true(
+    $string.contains(compiled.skill_md, "metadata.openclaw:"),
+  );
+}
+
+export function claude_code_flat_frontmatter_test() {
+  let $ = $compiler.compile("test/fixtures/valid-skill", "claude-code");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      110,
+      "claude_code_flat_frontmatter_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 4123,
+        end: 4213,
+        pattern_start: 4134,
+        pattern_end: 4146
+      }
+    )
+  }
+  $should.be_true(
+    $string.contains(compiled.skill_md, "disable-model-invocation: false"),
+  );
+  return $should.be_true(
+    $string.contains(compiled.skill_md, "user-invocable: true"),
+  );
+}
+
+export function codex_minimal_frontmatter_test() {
+  let $ = $compiler.compile("test/fixtures/valid-skill", "codex");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      121,
+      "codex_minimal_frontmatter_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 4488,
+        end: 4572,
+        pattern_start: 4499,
+        pattern_end: 4511
+      }
+    )
+  }
+  $should.be_true($string.contains(compiled.skill_md, "name: test-skill"));
+  return $should.be_true($string.contains(compiled.skill_md, "version: 1.2.3"));
+}
+
+export function metadata_conflict_provider_wins_test() {
+  let $ = $compiler.compile("test/fixtures/conflict-metadata", "openclaw");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      130,
+      "metadata_conflict_provider_wins_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 4889,
+        end: 4982,
+        pattern_start: 4900,
+        pattern_end: 4912
+      }
+    )
+  }
+  return $should.be_true(
+    $string.contains(compiled.skill_md, "OpenClaw-specific description"),
+  );
+}
+
+export function metadata_conflict_name_preserved_test() {
+  let $ = $compiler.compile("test/fixtures/conflict-metadata", "openclaw");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      141,
+      "metadata_conflict_name_preserved_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 5274,
+        end: 5367,
+        pattern_start: 5285,
+        pattern_end: 5297
+      }
+    )
+  }
+  return $should.be_true(
+    $string.contains(compiled.skill_md, "name: conflict-test"),
+  );
+}
+
+export function instructions_rendered_test() {
+  let $ = $compiler.compile("test/fixtures/valid-skill", "openclaw");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      151,
+      "instructions_rendered_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 5677,
+        end: 5764,
+        pattern_start: 5688,
+        pattern_end: 5700
+      }
+    )
+  }
+  $should.be_true($string.contains(compiled.skill_md, "test-skill v1.2.3"));
+  $should.be_false($string.contains(compiled.skill_md, "{{name}}"));
+  return $should.be_false($string.contains(compiled.skill_md, "{{version}}"));
+}
+
+export function provider_specific_content_included_test() {
+  let $ = $compiler.compile("test/fixtures/valid-skill", "openclaw");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      160,
+      "provider_specific_content_included_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 6074,
+        end: 6161,
+        pattern_start: 6085,
+        pattern_end: 6097
+      }
+    )
+  }
+  $should.be_true($string.contains(compiled.skill_md, "OpenClaw Notes"));
+  return $should.be_false(
+    $string.contains(compiled.skill_md, "Claude Code Notes"),
+  );
+}
+
+export function provider_specific_content_excluded_test() {
+  let $ = $compiler.compile("test/fixtures/valid-skill", "claude-code");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      167,
+      "provider_specific_content_excluded_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 6364,
+        end: 6454,
+        pattern_start: 6375,
+        pattern_end: 6387
+      }
+    )
+  }
+  $should.be_true($string.contains(compiled.skill_md, "Claude Code Notes"));
+  return $should.be_false($string.contains(compiled.skill_md, "OpenClaw Notes"));
+}
+
+export function multi_provider_content_openclaw_test() {
+  let $ = $compiler.compile("test/fixtures/valid-skill", "openclaw");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      174,
+      "multi_provider_content_openclaw_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 6654,
+        end: 6741,
+        pattern_start: 6665,
+        pattern_end: 6677
+      }
+    )
+  }
+  return $should.be_true($string.contains(compiled.skill_md, "Shared Notes"));
+}
+
+export function multi_provider_content_codex_test() {
+  let $ = $compiler.compile("test/fixtures/valid-skill", "codex");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      180,
+      "multi_provider_content_codex_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 6861,
+        end: 6945,
+        pattern_start: 6872,
+        pattern_end: 6884
+      }
+    )
+  }
+  return $should.be_true($string.contains(compiled.skill_md, "Shared Notes"));
+}
+
+export function multi_provider_content_excluded_test() {
+  let $ = $compiler.compile("test/fixtures/valid-skill", "claude-code");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      186,
+      "multi_provider_content_excluded_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 7068,
+        end: 7158,
+        pattern_start: 7079,
+        pattern_end: 7091
+      }
+    )
+  }
+  return $should.be_false($string.contains(compiled.skill_md, "Shared Notes"));
+}
+
+export function provider_instructions_appended_test() {
+  let $ = $compiler.compile("test/fixtures/valid-skill", "openclaw");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      193,
+      "provider_instructions_appended_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 7357,
+        end: 7444,
+        pattern_start: 7368,
+        pattern_end: 7380
+      }
+    )
+  }
+  $should.be_true(
+    $string.contains(compiled.skill_md, "OpenClaw-Specific Setup"),
+  );
+  return $should.be_true(
+    $string.contains(compiled.skill_md, "pip install test-cli"),
+  );
+}
+
+export function provider_without_instructions_ok_test() {
+  let $ = $compiler.compile("test/fixtures/valid-skill", "claude-code");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      201,
+      "provider_without_instructions_ok_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 7739,
+        end: 7829,
+        pattern_start: 7750,
+        pattern_end: 7762
+      }
+    )
+  }
+  return $should.be_false(
+    $string.contains(compiled.skill_md, "OpenClaw-Specific Setup"),
+  );
+}
+
+export function template_directives_fully_resolved_test() {
+  let $ = $compiler.compile("test/fixtures/valid-skill", "openclaw");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      207,
+      "template_directives_fully_resolved_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 7967,
+        end: 8054,
+        pattern_start: 7978,
+        pattern_end: 7990
+      }
+    )
+  }
+  $should.be_false($string.contains(compiled.skill_md, "{{#provider"));
+  $should.be_false($string.contains(compiled.skill_md, "{{/provider}}"));
+  return $should.be_false($string.contains(compiled.skill_md, "{{name}}"));
+}
+
+export function shared_scripts_collected_test() {
+  let $ = $compiler.compile("test/fixtures/valid-skill", "claude-code");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      221,
+      "shared_scripts_collected_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 8634,
+        end: 8724,
+        pattern_start: 8645,
+        pattern_end: 8657
+      }
+    )
+  }
+  let script_paths = $list.map(
+    compiled.scripts,
+    (f) => { return f.relative_path; },
+  );
+  $should.be_true($list.contains(script_paths, "common.sh"));
+  return $should.be_true($list.contains(script_paths, "shared.sh"));
+}
+
+export function provider_script_overrides_shared_test() {
+  let $ = $compiler.compile("test/fixtures/valid-skill", "openclaw");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      230,
+      "provider_script_overrides_shared_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 9044,
+        end: 9131,
+        pattern_start: 9055,
+        pattern_end: 9067
+      }
+    )
+  }
+  let script_paths = $list.map(
+    compiled.scripts,
+    (f) => { return f.relative_path; },
+  );
+  $should.be_true($list.contains(script_paths, "common.sh"));
+  let $1 = $list.find(
+    compiled.scripts,
+    (f) => { return f.relative_path === "common.sh"; },
+  );
+  let common;
+  if ($1 instanceof Ok) {
+    common = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      235,
+      "provider_script_overrides_shared_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 9339,
+        end: 9436,
+        pattern_start: 9350,
+        pattern_end: 9360
+      }
+    )
+  }
+  return $should.be_true(
+    $string.contains(common.src, "providers/openclaw/scripts"),
+  );
+}
+
+export function provider_adds_extra_scripts_test() {
+  let $ = $compiler.compile("test/fixtures/valid-skill", "openclaw");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      242,
+      "provider_adds_extra_scripts_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 9626,
+        end: 9713,
+        pattern_start: 9637,
+        pattern_end: 9649
+      }
+    )
+  }
+  let script_paths = $list.map(
+    compiled.scripts,
+    (f) => { return f.relative_path; },
+  );
+  return $should.be_true($list.contains(script_paths, "openclaw-only.sh"));
+}
+
+export function shared_scripts_not_overridden_preserved_test() {
+  let $ = $compiler.compile("test/fixtures/valid-skill", "openclaw");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      250,
+      "shared_scripts_not_overridden_preserved_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 9988,
+        end: 10075,
+        pattern_start: 9999,
+        pattern_end: 10011
+      }
+    )
+  }
+  let script_paths = $list.map(
+    compiled.scripts,
+    (f) => { return f.relative_path; },
+  );
+  return $should.be_true($list.contains(script_paths, "shared.sh"));
+}
+
+export function shared_assets_collected_test() {
+  let $ = $compiler.compile("test/fixtures/valid-skill", "openclaw");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      257,
+      "shared_assets_collected_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 10255,
+        end: 10342,
+        pattern_start: 10266,
+        pattern_end: 10278
+      }
+    )
+  }
+  let asset_paths = $list.map(
+    compiled.assets,
+    (f) => { return f.relative_path; },
+  );
+  return $should.be_true($list.contains(asset_paths, "template.md"));
+}
+
+export function no_scripts_dir_produces_empty_list_test() {
+  let $ = $compiler.compile("test/fixtures/minimal-skill", "openclaw");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      265,
+      "no_scripts_dir_produces_empty_list_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 10576,
+        end: 10665,
+        pattern_start: 10587,
+        pattern_end: 10599
+      }
+    )
+  }
+  return $should.equal(compiled.scripts, toList([]));
+}
+
+export function emit_creates_output_structure_test() {
+  let output_dir = "/tmp/skillc-test-emit";
+  let $ = $simplifile.delete$(output_dir);
+  
+  let $1 = $compiler.compile("test/fixtures/valid-skill", "openclaw");
+  let compiled;
+  if ($1 instanceof Ok) {
+    compiled = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      279,
+      "emit_creates_output_structure_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 11067,
+        end: 11154,
+        pattern_start: 11078,
+        pattern_end: 11090
+      }
+    )
+  }
+  let $2 = $compiler.emit(compiled, output_dir, "test-skill");
+  if (!($2 instanceof Ok)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      281,
+      "emit_creates_output_structure_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $2,
+        start: 11157,
+        end: 11225,
+        pattern_start: 11168,
+        pattern_end: 11173
+      }
+    )
+  }
+  let $3 = $simplifile.read(output_dir + "/openclaw/test-skill/SKILL.md");
+  let content;
+  if ($3 instanceof Ok) {
+    content = $3[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      284,
+      "emit_creates_output_structure_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $3,
+        start: 11255,
+        end: 11346,
+        pattern_start: 11266,
+        pattern_end: 11277
+      }
+    )
+  }
+  $should.be_true($string.contains(content, "test-skill"));
+  let $4 = $simplifile.delete$(output_dir);
+  
+  return undefined;
+}
+
+export function emit_codex_structure_test() {
+  let output_dir = "/tmp/skillc-test-emit-codex";
+  let $ = $simplifile.delete$(output_dir);
+  
+  let $1 = $compiler.compile("test/fixtures/valid-skill", "codex");
+  let compiled;
+  if ($1 instanceof Ok) {
+    compiled = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      297,
+      "emit_codex_structure_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 11597,
+        end: 11681,
+        pattern_start: 11608,
+        pattern_end: 11620
+      }
+    )
+  }
+  let $2 = $compiler.emit(compiled, output_dir, "test-skill");
+  if (!($2 instanceof Ok)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      299,
+      "emit_codex_structure_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $2,
+        start: 11684,
+        end: 11752,
+        pattern_start: 11695,
+        pattern_end: 11700
+      }
+    )
+  }
+  let $3 = $simplifile.read(
+    output_dir + "/codex/.agents/skills/test-skill/SKILL.md",
+  );
+  let content;
+  if ($3 instanceof Ok) {
+    content = $3[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      302,
+      "emit_codex_structure_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $3,
+        start: 11799,
+        end: 11902,
+        pattern_start: 11810,
+        pattern_end: 11821
+      }
+    )
+  }
+  $should.be_true($string.contains(content, "test-skill"));
+  let $4 = $simplifile.delete$(output_dir);
+  
+  return undefined;
+}
+
+export function compile_nonexistent_directory_fails_test() {
+  let result = $compiler.compile("/tmp/nonexistent-skill-dir-xyz", "openclaw");
+  return $should.be_error(result);
+}
+
+export function compile_unsupported_provider_fails_test() {
+  let result = $compiler.compile(
+    "test/fixtures/valid-skill",
+    "nonexistent-provider",
+  );
+  $should.be_error(result);
+  if (result instanceof Error) {
+    let $ = result[0];
+    if (!($ instanceof $error.ProviderError)) {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "compiler_test",
+        323,
+        "compile_unsupported_provider_fails_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 12522,
+          end: 12574,
+          pattern_start: 12533,
+          pattern_end: 12565
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      323,
+      "compile_unsupported_provider_fails_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 12522,
+        end: 12574,
+        pattern_start: 12533,
+        pattern_end: 12565
+      }
+    )
+  }
+  return result;
+}
+
+export function compile_no_providers_fails_test() {
+  let result = $compiler.compile_all("test/fixtures/no-providers");
+  return $should.be_error(result);
+}
+
+export function compile_missing_instructions_fails_test() {
+  let result = $compiler.compile(
+    "test/fixtures/missing-instructions",
+    "openclaw",
+  );
+  $should.be_error(result);
+  if (result instanceof Error) {
+    let $ = result[0];
+    if (!($ instanceof $error.FileError)) {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "compiler_test",
+        336,
+        "compile_missing_instructions_fails_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 12938,
+          end: 12986,
+          pattern_start: 12949,
+          pattern_end: 12977
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      336,
+      "compile_missing_instructions_fails_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 12938,
+        end: 12986,
+        pattern_start: 12949,
+        pattern_end: 12977
+      }
+    )
+  }
+  return result;
+}
+
+export function compile_empty_instructions_succeeds_test() {
+  let result = $compiler.compile("test/fixtures/empty-instructions", "openclaw");
+  return $should.be_ok(result);
+}
+
+export function compile_invalid_yaml_fails_test() {
+  let result = $compiler.compile("test/fixtures/invalid-yaml", "openclaw");
+  return $should.be_error(result);
+}
+
+export function compile_missing_fields_fails_test() {
+  let result = $compiler.compile("test/fixtures/missing-name", "openclaw");
+  return $should.be_error(result);
+}
+
+export function compile_unsupported_provider_error_message_test() {
+  let result = $compiler.compile(
+    "test/fixtures/valid-skill",
+    "nonexistent-provider",
+  );
+  let provider;
+  let msg;
+  if (result instanceof Error) {
+    let $ = result[0];
+    if ($ instanceof $error.ProviderError) {
+      provider = $.provider;
+      msg = $.message;
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "compiler_test",
+        362,
+        "compile_unsupported_provider_error_message_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 13864,
+          end: 13925,
+          pattern_start: 13875,
+          pattern_end: 13916
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      362,
+      "compile_unsupported_provider_error_message_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 13864,
+        end: 13925,
+        pattern_start: 13875,
+        pattern_end: 13916
+      }
+    )
+  }
+  $should.equal(provider, "nonexistent-provider");
+  return $should.be_true($string.contains(msg, "Unknown provider"));
+}
+
+export function compile_missing_instructions_error_message_test() {
+  let result = $compiler.compile(
+    "test/fixtures/missing-instructions",
+    "openclaw",
+  );
+  let path;
+  if (result instanceof Error) {
+    let $ = result[0];
+    if ($ instanceof $error.FileError) {
+      path = $.path;
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "compiler_test",
+        370,
+        "compile_missing_instructions_error_message_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 14184,
+          end: 14235,
+          pattern_start: 14195,
+          pattern_end: 14226
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      370,
+      "compile_missing_instructions_error_message_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 14184,
+        end: 14235,
+        pattern_start: 14195,
+        pattern_end: 14226
+      }
+    )
+  }
+  return $should.be_true($string.contains(path, "INSTRUCTIONS.md"));
+}
+
+export function frontmatter_instructions_generates_warning_test() {
+  let $ = $compiler.compile(
+    "test/fixtures/frontmatter-instructions",
+    "openclaw",
+  );
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      379,
+      "frontmatter_instructions_generates_warning_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 14555,
+        end: 14655,
+        pattern_start: 14566,
+        pattern_end: 14578
+      }
+    )
+  }
+  $should.equal($list.length(compiled.warnings), 1);
+  let $1 = compiled.warnings;
+  let file;
+  if ($1 instanceof $Empty) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      382,
+      "frontmatter_instructions_generates_warning_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 14708,
+        end: 14778,
+        pattern_start: 14719,
+        pattern_end: 14758
+      }
+    )
+  } else {
+    let $2 = $1.head;
+    if ($2 instanceof $types.FrontmatterInInstructions) {
+      let $3 = $1.tail;
+      if ($3 instanceof $Empty) {
+        file = $2.file;
+      } else {
+        throw makeError(
+          "let_assert",
+          FILEPATH,
+          "compiler_test",
+          382,
+          "frontmatter_instructions_generates_warning_test",
+          "Pattern match failed, no pattern matched the value.",
+          {
+            value: $1,
+            start: 14708,
+            end: 14778,
+            pattern_start: 14719,
+            pattern_end: 14758
+          }
+        )
+      }
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "compiler_test",
+        382,
+        "frontmatter_instructions_generates_warning_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: $1,
+          start: 14708,
+          end: 14778,
+          pattern_start: 14719,
+          pattern_end: 14758
+        }
+      )
+    }
+  }
+  return $should.be_true($string.contains(file, "INSTRUCTIONS.md"));
+}
+
+export function normal_instructions_no_warnings_test() {
+  let $ = $compiler.compile("test/fixtures/valid-skill", "openclaw");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      387,
+      "normal_instructions_no_warnings_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 14891,
+        end: 14978,
+        pattern_start: 14902,
+        pattern_end: 14914
+      }
+    )
+  }
+  return $should.equal(compiled.warnings, toList([]));
+}
+
+export function emit_roundtrip_content_matches_test() {
+  let output_dir = "/tmp/skillc-test-roundtrip";
+  let $ = $simplifile.delete$(output_dir);
+  
+  let $1 = $compiler.compile("test/fixtures/valid-skill", "openclaw");
+  let compiled;
+  if ($1 instanceof Ok) {
+    compiled = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      400,
+      "emit_roundtrip_content_matches_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 15350,
+        end: 15437,
+        pattern_start: 15361,
+        pattern_end: 15373
+      }
+    )
+  }
+  let $2 = $compiler.emit(compiled, output_dir, "test-skill");
+  if (!($2 instanceof Ok)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      402,
+      "emit_roundtrip_content_matches_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $2,
+        start: 15440,
+        end: 15508,
+        pattern_start: 15451,
+        pattern_end: 15456
+      }
+    )
+  }
+  let $3 = $simplifile.read(output_dir + "/openclaw/test-skill/SKILL.md");
+  let read_back;
+  if ($3 instanceof Ok) {
+    read_back = $3[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      405,
+      "emit_roundtrip_content_matches_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $3,
+        start: 15562,
+        end: 15655,
+        pattern_start: 15573,
+        pattern_end: 15586
+      }
+    )
+  }
+  $should.equal(read_back, compiled.skill_md);
+  let $4 = $simplifile.delete$(output_dir);
+  
+  return undefined;
+}
+
+export function emit_roundtrip_codex_content_matches_test() {
+  let output_dir = "/tmp/skillc-test-roundtrip-codex";
+  let $ = $simplifile.delete$(output_dir);
+  
+  let $1 = $compiler.compile("test/fixtures/valid-skill", "codex");
+  let compiled;
+  if ($1 instanceof Ok) {
+    compiled = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      417,
+      "emit_roundtrip_codex_content_matches_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 15901,
+        end: 15985,
+        pattern_start: 15912,
+        pattern_end: 15924
+      }
+    )
+  }
+  let $2 = $compiler.emit(compiled, output_dir, "test-skill");
+  if (!($2 instanceof Ok)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      419,
+      "emit_roundtrip_codex_content_matches_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $2,
+        start: 15988,
+        end: 16056,
+        pattern_start: 15999,
+        pattern_end: 16004
+      }
+    )
+  }
+  let $3 = $simplifile.read(
+    output_dir + "/codex/.agents/skills/test-skill/SKILL.md",
+  );
+  let read_back;
+  if ($3 instanceof Ok) {
+    read_back = $3[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      421,
+      "emit_roundtrip_codex_content_matches_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $3,
+        start: 16060,
+        end: 16165,
+        pattern_start: 16071,
+        pattern_end: 16084
+      }
+    )
+  }
+  $should.equal(read_back, compiled.skill_md);
+  let $4 = $simplifile.delete$(output_dir);
+  
+  return undefined;
+}
+
+export function emit_script_content_verified_test() {
+  let output_dir = "/tmp/skillc-test-script-content";
+  let $ = $simplifile.delete$(output_dir);
+  
+  let $1 = $compiler.compile("test/fixtures/valid-skill", "openclaw");
+  let compiled;
+  if ($1 instanceof Ok) {
+    compiled = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      433,
+      "emit_script_content_verified_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 16402,
+        end: 16489,
+        pattern_start: 16413,
+        pattern_end: 16425
+      }
+    )
+  }
+  let $2 = $compiler.emit(compiled, output_dir, "test-skill");
+  if (!($2 instanceof Ok)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      435,
+      "emit_script_content_verified_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $2,
+        start: 16492,
+        end: 16560,
+        pattern_start: 16503,
+        pattern_end: 16508
+      }
+    )
+  }
+  let $3 = $simplifile.read(
+    output_dir + "/openclaw/test-skill/scripts/common.sh",
+  );
+  let content;
+  if ($3 instanceof Ok) {
+    content = $3[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      438,
+      "emit_script_content_verified_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $3,
+        start: 16648,
+        end: 16748,
+        pattern_start: 16659,
+        pattern_end: 16670
+      }
+    )
+  }
+  $should.be_true($string.contains(content, "openclaw override"));
+  let $4 = $simplifile.read(
+    output_dir + "/openclaw/test-skill/scripts/shared.sh",
+  );
+  let shared_content;
+  if ($4 instanceof Ok) {
+    shared_content = $4[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      443,
+      "emit_script_content_verified_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $4,
+        start: 16877,
+        end: 16984,
+        pattern_start: 16888,
+        pattern_end: 16906
+      }
+    )
+  }
+  $should.be_true($string.contains(shared_content, "shared script"));
+  let $5 = $simplifile.delete$(output_dir);
+  
+  return undefined;
+}
+
+export function golden_openclaw_output_test() {
+  let $ = $compiler.compile("test/fixtures/valid-skill", "openclaw");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      456,
+      "golden_openclaw_output_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 17354,
+        end: 17441,
+        pattern_start: 17365,
+        pattern_end: 17377
+      }
+    )
+  }
+  let $1 = $simplifile.read("test/golden/valid-skill.openclaw.md");
+  let expected;
+  if ($1 instanceof Ok) {
+    expected = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      458,
+      "golden_openclaw_output_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 17444,
+        end: 17528,
+        pattern_start: 17455,
+        pattern_end: 17467
+      }
+    )
+  }
+  return $should.equal(compiled.skill_md, expected);
+}
+
+export function golden_claude_code_output_test() {
+  let $ = $compiler.compile("test/fixtures/valid-skill", "claude-code");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      464,
+      "golden_claude_code_output_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 17620,
+        end: 17710,
+        pattern_start: 17631,
+        pattern_end: 17643
+      }
+    )
+  }
+  let $1 = $simplifile.read("test/golden/valid-skill.claude-code.md");
+  let expected;
+  if ($1 instanceof Ok) {
+    expected = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      466,
+      "golden_claude_code_output_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 17713,
+        end: 17800,
+        pattern_start: 17724,
+        pattern_end: 17736
+      }
+    )
+  }
+  return $should.equal(compiled.skill_md, expected);
+}
+
+export function golden_codex_output_test() {
+  let $ = $compiler.compile("test/fixtures/valid-skill", "codex");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      472,
+      "golden_codex_output_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 17886,
+        end: 17970,
+        pattern_start: 17897,
+        pattern_end: 17909
+      }
+    )
+  }
+  let $1 = $simplifile.read("test/golden/valid-skill.codex.md");
+  let expected;
+  if ($1 instanceof Ok) {
+    expected = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      474,
+      "golden_codex_output_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 17973,
+        end: 18050,
+        pattern_start: 17984,
+        pattern_end: 17996
+      }
+    )
+  }
+  return $should.equal(compiled.skill_md, expected);
+}
+
+export function compile_hello_world_openclaw_test() {
+  let $ = $compiler.compile("../examples/hello-world", "openclaw");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      483,
+      "compile_hello_world_openclaw_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 18348,
+        end: 18433,
+        pattern_start: 18359,
+        pattern_end: 18371
+      }
+    )
+  }
+  $should.be_true($string.contains(compiled.skill_md, "hello-world v1.0.0"));
+  $should.be_true($string.contains(compiled.skill_md, "OpenClaw Notes"));
+  $should.be_false($string.contains(compiled.skill_md, "Claude Code Notes"));
+  return $should.be_false($string.contains(compiled.skill_md, "{{name}}"));
+}
+
+export function compile_hello_world_claude_code_test() {
+  let $ = $compiler.compile("../examples/hello-world", "claude-code");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      492,
+      "compile_hello_world_claude_code_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 18774,
+        end: 18862,
+        pattern_start: 18785,
+        pattern_end: 18797
+      }
+    )
+  }
+  $should.be_true($string.contains(compiled.skill_md, "hello-world v1.0.0"));
+  $should.be_true($string.contains(compiled.skill_md, "Claude Code Notes"));
+  return $should.be_false($string.contains(compiled.skill_md, "OpenClaw Notes"));
+}
+
+export function compile_hello_world_codex_test() {
+  let $ = $compiler.compile("../examples/hello-world", "codex");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      500,
+      "compile_hello_world_codex_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 19131,
+        end: 19209,
+        pattern_start: 19142,
+        pattern_end: 19154
+      }
+    )
+  }
+  $should.be_true($string.contains(compiled.skill_md, "hello-world v1.0.0"));
+  $should.be_false($string.contains(compiled.skill_md, "OpenClaw Notes"));
+  return $should.be_false(
+    $string.contains(compiled.skill_md, "Claude Code Notes"),
+  );
+}
+
+export function compile_hello_world_all_providers_test() {
+  let $ = $compiler.compile_all("../examples/hello-world");
+  let compiled_list;
+  if ($ instanceof Ok) {
+    compiled_list = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      507,
+      "compile_hello_world_all_providers_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 19487,
+        end: 19565,
+        pattern_start: 19498,
+        pattern_end: 19515
+      }
+    )
+  }
+  return $should.equal($list.length(compiled_list), 3);
+}
+
+export function escaped_syntax_preserved_in_output_test() {
+  let $ = $compiler.compile("test/fixtures/valid-skill", "openclaw");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      518,
+      "escaped_syntax_preserved_in_output_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 20012,
+        end: 20099,
+        pattern_start: 20023,
+        pattern_end: 20035
+      }
+    )
+  }
+  $should.be_false($string.contains(compiled.skill_md, "{{name}}"));
+  $should.be_false($string.contains(compiled.skill_md, "{{version}}"));
+  return $should.be_false(
+    $string.contains(compiled.skill_md, "{{description}}"),
+  );
+}
+
+export function emit_with_scripts_test() {
+  let output_dir = "/tmp/skillc-test-emit-scripts";
+  let $ = $simplifile.delete$(output_dir);
+  
+  let $1 = $compiler.compile("test/fixtures/valid-skill", "openclaw");
+  let compiled;
+  if ($1 instanceof Ok) {
+    compiled = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      535,
+      "emit_with_scripts_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 20768,
+        end: 20855,
+        pattern_start: 20779,
+        pattern_end: 20791
+      }
+    )
+  }
+  let $2 = $compiler.emit(compiled, output_dir, "test-skill");
+  if (!($2 instanceof Ok)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      537,
+      "emit_with_scripts_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $2,
+        start: 20858,
+        end: 20926,
+        pattern_start: 20869,
+        pattern_end: 20874
+      }
+    )
+  }
+  let skill_dir = output_dir + "/openclaw/test-skill";
+  let $3 = $simplifile.is_file(skill_dir + "/scripts/common.sh");
+  if ($3 instanceof Ok) {
+    let $4 = $3[0];
+    if (!($4)) {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "compiler_test",
+        541,
+        "emit_with_scripts_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: $3,
+          start: 21017,
+          end: 21092,
+          pattern_start: 21028,
+          pattern_end: 21036
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      541,
+      "emit_with_scripts_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $3,
+        start: 21017,
+        end: 21092,
+        pattern_start: 21028,
+        pattern_end: 21036
+      }
+    )
+  }
+  let $5 = $simplifile.is_file(skill_dir + "/scripts/shared.sh");
+  if ($5 instanceof Ok) {
+    let $6 = $5[0];
+    if (!($6)) {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "compiler_test",
+        542,
+        "emit_with_scripts_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: $5,
+          start: 21095,
+          end: 21170,
+          pattern_start: 21106,
+          pattern_end: 21114
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      542,
+      "emit_with_scripts_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $5,
+        start: 21095,
+        end: 21170,
+        pattern_start: 21106,
+        pattern_end: 21114
+      }
+    )
+  }
+  let $7 = $simplifile.is_file(skill_dir + "/scripts/openclaw-only.sh");
+  if ($7 instanceof Ok) {
+    let $8 = $7[0];
+    if (!($8)) {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "compiler_test",
+        543,
+        "emit_with_scripts_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: $7,
+          start: 21173,
+          end: 21259,
+          pattern_start: 21184,
+          pattern_end: 21192
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      543,
+      "emit_with_scripts_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $7,
+        start: 21173,
+        end: 21259,
+        pattern_start: 21184,
+        pattern_end: 21192
+      }
+    )
+  }
+  let $9 = $simplifile.is_file(skill_dir + "/assets/template.md");
+  if ($9 instanceof Ok) {
+    let $10 = $9[0];
+    if (!($10)) {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "compiler_test",
+        547,
+        "emit_with_scripts_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: $9,
+          start: 21294,
+          end: 21370,
+          pattern_start: 21305,
+          pattern_end: 21313
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      547,
+      "emit_with_scripts_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $9,
+        start: 21294,
+        end: 21370,
+        pattern_start: 21305,
+        pattern_end: 21313
+      }
+    )
+  }
+  let $11 = $simplifile.delete$(output_dir);
+  
+  return undefined;
+}
+
+export function emit_claude_code_structure_test() {
+  let output_dir = "/tmp/skillc-test-emit-cc";
+  let $ = $simplifile.delete$(output_dir);
+  
+  let $1 = $compiler.compile("test/fixtures/valid-skill", "claude-code");
+  let compiled;
+  if ($1 instanceof Ok) {
+    compiled = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      557,
+      "emit_claude_code_structure_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 21553,
+        end: 21643,
+        pattern_start: 21564,
+        pattern_end: 21576
+      }
+    )
+  }
+  let $2 = $compiler.emit(compiled, output_dir, "test-skill");
+  if (!($2 instanceof Ok)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      559,
+      "emit_claude_code_structure_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $2,
+        start: 21646,
+        end: 21714,
+        pattern_start: 21657,
+        pattern_end: 21662
+      }
+    )
+  }
+  let $3 = $simplifile.read(output_dir + "/claude-code/test-skill/SKILL.md");
+  let content;
+  if ($3 instanceof Ok) {
+    content = $3[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      562,
+      "emit_claude_code_structure_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $3,
+        start: 21781,
+        end: 21875,
+        pattern_start: 21792,
+        pattern_end: 21803
+      }
+    )
+  }
+  $should.be_true($string.contains(content, "test-skill"));
+  let $4 = $simplifile.delete$(output_dir);
+  
+  return undefined;
+}
+
+export function name_with_special_chars_produces_quoted_yaml_test() {
+  let $ = $compiler.compile("test/fixtures/conflict-metadata", "openclaw");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      577,
+      "name_with_special_chars_produces_quoted_yaml_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 22361,
+        end: 22454,
+        pattern_start: 22372,
+        pattern_end: 22384
+      }
+    )
+  }
+  $should.be_true($string.contains(compiled.skill_md, "name: conflict-test"));
+  return $should.be_true(
+    $string.contains(
+      compiled.skill_md,
+      "description: \"OpenClaw-specific description\"",
+    ),
+  );
+}
+
+export function quote_yaml_string_with_newline_test() {
+  let $ = $compiler.compile("test/fixtures/valid-skill", "codex");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      596,
+      "quote_yaml_string_with_newline_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 23294,
+        end: 23378,
+        pattern_start: 23305,
+        pattern_end: 23317
+      }
+    )
+  }
+  return $should.be_true(
+    $string.contains(
+      compiled.skill_md,
+      "description: \"A test skill for validation\"",
+    ),
+  );
+}
+
+export function unknown_provider_string_returns_error_test() {
+  let result = $compiler.compile(
+    "test/fixtures/unknown-provider",
+    "my-custom-provider",
+  );
+  $should.be_error(result);
+  let provider;
+  let msg;
+  if (result instanceof Error) {
+    let $ = result[0];
+    if ($ instanceof $error.ProviderError) {
+      provider = $.provider;
+      msg = $.message;
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "compiler_test",
+        613,
+        "unknown_provider_string_returns_error_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 23929,
+          end: 23990,
+          pattern_start: 23940,
+          pattern_end: 23981
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      613,
+      "unknown_provider_string_returns_error_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 23929,
+        end: 23990,
+        pattern_start: 23940,
+        pattern_end: 23981
+      }
+    )
+  }
+  $should.equal(provider, "my-custom-provider");
+  return $should.be_true($string.contains(msg, "Unknown provider"));
+}
+
+export function compile_all_unknown_provider_silently_skipped_test() {
+  let $ = $compiler.compile_all("test/fixtures/unknown-provider");
+  let compiled_list;
+  if ($ instanceof Ok) {
+    compiled_list = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      621,
+      "compile_all_unknown_provider_silently_skipped_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 24310,
+        end: 24399,
+        pattern_start: 24321,
+        pattern_end: 24338
+      }
+    )
+  }
+  $should.equal($list.length(compiled_list), 1);
+  let compiled;
+  if (compiled_list instanceof $Empty) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      624,
+      "compile_all_unknown_provider_silently_skipped_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: compiled_list,
+        start: 24448,
+        end: 24485,
+        pattern_start: 24459,
+        pattern_end: 24469
+      }
+    )
+  } else {
+    let $1 = compiled_list.tail;
+    if ($1 instanceof $Empty) {
+      compiled = compiled_list.head;
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "compiler_test",
+        624,
+        "compile_all_unknown_provider_silently_skipped_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: compiled_list,
+          start: 24448,
+          end: 24485,
+          pattern_start: 24459,
+          pattern_end: 24469
+        }
+      )
+    }
+  }
+  $should.equal(compiled.provider, new $types.OpenClaw());
+  return $should.equal(compiled.warnings, toList([]));
+}
+
+export function provider_specific_assets_override_shared_test() {
+  let $ = $compiler.compile("test/fixtures/valid-skill", "openclaw");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      632,
+      "provider_specific_assets_override_shared_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 24760,
+        end: 24847,
+        pattern_start: 24771,
+        pattern_end: 24783
+      }
+    )
+  }
+  let $1 = $list.find(
+    compiled.assets,
+    (f) => { return f.relative_path === "template.md"; },
+  );
+  let template_asset;
+  if ($1 instanceof Ok) {
+    template_asset = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      634,
+      "provider_specific_assets_override_shared_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 24850,
+        end: 24956,
+        pattern_start: 24861,
+        pattern_end: 24879
+      }
+    )
+  }
+  return $should.be_true(
+    $string.contains(template_asset.src, "providers/openclaw/assets"),
+  );
+}
+
+export function has_frontmatter_with_leading_whitespace_integration_test() {
+  let $ = $compiler.compile("test/fixtures/valid-skill", "openclaw");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      646,
+      "has_frontmatter_with_leading_whitespace_integration_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 25337,
+        end: 25424,
+        pattern_start: 25348,
+        pattern_end: 25360
+      }
+    )
+  }
+  return $should.equal(compiled.warnings, toList([]));
+}
+
+export function version_function_returns_expected_value_test() {
+  let v = $skillc.version();
+  return $should.equal(v, "1.1.0");
+}
+
+export function codex_compile_produces_codex_yaml_test() {
+  let $ = $compiler.compile("test/fixtures/valid-skill", "codex");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      662,
+      "codex_compile_produces_codex_yaml_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 25900,
+        end: 25984,
+        pattern_start: 25911,
+        pattern_end: 25923
+      }
+    )
+  }
+  $should.be_true($option.is_some(compiled.codex_yaml));
+  let $1 = compiled.codex_yaml;
+  let yaml;
+  if ($1 instanceof $option.Some) {
+    yaml = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      665,
+      "codex_compile_produces_codex_yaml_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 26041,
+        end: 26091,
+        pattern_start: 26052,
+        pattern_end: 26069
+      }
+    )
+  }
+  $should.be_true($string.contains(yaml, "interface:"));
+  $should.be_true($string.contains(yaml, "display_name:"));
+  return $should.be_true($string.contains(yaml, "policy:"));
+}
+
+export function openclaw_compile_no_codex_yaml_test() {
+  let $ = $compiler.compile("test/fixtures/valid-skill", "openclaw");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      672,
+      "openclaw_compile_no_codex_yaml_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 26306,
+        end: 26393,
+        pattern_start: 26317,
+        pattern_end: 26329
+      }
+    )
+  }
+  return $should.be_true($option.is_none(compiled.codex_yaml));
+}
+
+export function claude_code_compile_no_codex_yaml_test() {
+  let $ = $compiler.compile("test/fixtures/valid-skill", "claude-code");
+  let compiled;
+  if ($ instanceof Ok) {
+    compiled = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      678,
+      "claude_code_compile_no_codex_yaml_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 26503,
+        end: 26593,
+        pattern_start: 26514,
+        pattern_end: 26526
+      }
+    )
+  }
+  return $should.be_true($option.is_none(compiled.codex_yaml));
+}
+
+export function emit_codex_generates_openai_yaml_test() {
+  let output_dir = "/tmp/skillc-test-codex-yaml";
+  let $ = $simplifile.delete$(output_dir);
+  
+  let $1 = $compiler.compile("test/fixtures/valid-skill", "codex");
+  let compiled;
+  if ($1 instanceof Ok) {
+    compiled = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      687,
+      "emit_codex_generates_openai_yaml_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 26792,
+        end: 26876,
+        pattern_start: 26803,
+        pattern_end: 26815
+      }
+    )
+  }
+  let $2 = $compiler.emit(compiled, output_dir, "test-skill");
+  if (!($2 instanceof Ok)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      689,
+      "emit_codex_generates_openai_yaml_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $2,
+        start: 26879,
+        end: 26947,
+        pattern_start: 26890,
+        pattern_end: 26895
+      }
+    )
+  }
+  let yaml_path = output_dir + "/codex/.agents/skills/test-skill/agents/openai.yaml";
+  let $3 = $simplifile.read(yaml_path);
+  let content;
+  if ($3 instanceof Ok) {
+    content = $3[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      693,
+      "emit_codex_generates_openai_yaml_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $3,
+        start: 27041,
+        end: 27092,
+        pattern_start: 27052,
+        pattern_end: 27063
+      }
+    )
+  }
+  $should.be_true($string.contains(content, "interface:"));
+  $should.be_true($string.contains(content, "display_name:"));
+  $should.be_true($string.contains(content, "policy:"));
+  let $4 = $simplifile.delete$(output_dir);
+  
+  return undefined;
+}
+
+export function compile_providers_single_test() {
+  let $ = $compiler.compile_providers(
+    "test/fixtures/valid-skill",
+    toList(["openclaw"]),
+  );
+  let compiled_list;
+  if ($ instanceof Ok) {
+    compiled_list = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      707,
+      "compile_providers_single_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 27583,
+        end: 27687,
+        pattern_start: 27594,
+        pattern_end: 27611
+      }
+    )
+  }
+  $should.equal($list.length(compiled_list), 1);
+  let compiled;
+  if (compiled_list instanceof $Empty) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      710,
+      "compile_providers_single_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: compiled_list,
+        start: 27736,
+        end: 27773,
+        pattern_start: 27747,
+        pattern_end: 27757
+      }
+    )
+  } else {
+    let $1 = compiled_list.tail;
+    if ($1 instanceof $Empty) {
+      compiled = compiled_list.head;
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "compiler_test",
+        710,
+        "compile_providers_single_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: compiled_list,
+          start: 27736,
+          end: 27773,
+          pattern_start: 27747,
+          pattern_end: 27757
+        }
+      )
+    }
+  }
+  return $should.equal(compiled.provider, new $types.OpenClaw());
+}
+
+export function compile_providers_multiple_test() {
+  let $ = $compiler.compile_providers(
+    "test/fixtures/valid-skill",
+    toList(["openclaw", "codex"]),
+  );
+  let compiled_list;
+  if ($ instanceof Ok) {
+    compiled_list = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      715,
+      "compile_providers_multiple_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 27872,
+        end: 27998,
+        pattern_start: 27883,
+        pattern_end: 27900
+      }
+    )
+  }
+  $should.equal($list.length(compiled_list), 2);
+  let providers = $list.map(compiled_list, (c) => { return c.provider; });
+  $should.be_true($list.contains(providers, new $types.OpenClaw()));
+  return $should.be_true($list.contains(providers, new $types.Codex()));
+}
+
+export function compile_providers_invalid_provider_fails_test() {
+  let result = $compiler.compile_providers(
+    "test/fixtures/valid-skill",
+    toList(["openclaw", "invalid"]),
+  );
+  $should.be_error(result);
+  if (result instanceof Error) {
+    let $ = result[0];
+    if ($ instanceof $error.ProviderError) {
+      let $1 = $.provider;
+      if (!($1 === "invalid")) {
+        throw makeError(
+          "let_assert",
+          FILEPATH,
+          "compiler_test",
+          731,
+          "compile_providers_invalid_provider_fails_test",
+          "Pattern match failed, no pattern matched the value.",
+          {
+            value: result,
+            start: 28425,
+            end: 28485,
+            pattern_start: 28436,
+            pattern_end: 28476
+          }
+        )
+      }
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "compiler_test",
+        731,
+        "compile_providers_invalid_provider_fails_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: result,
+          start: 28425,
+          end: 28485,
+          pattern_start: 28436,
+          pattern_end: 28476
+        }
+      )
+    }
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      731,
+      "compile_providers_invalid_provider_fails_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: result,
+        start: 28425,
+        end: 28485,
+        pattern_start: 28436,
+        pattern_end: 28476
+      }
+    )
+  }
+  return result;
+}
+
+export function compile_providers_empty_list_fails_test() {
+  let result = $compiler.compile_providers(
+    "test/fixtures/valid-skill",
+    toList([]),
+  );
+  return $should.be_error(result);
+}
+
+export function check_dependencies_missing_dep_warns_test() {
+  let $ = $simplifile.read("test/fixtures/skill-with-deps/skill.yaml");
+  let skill_content;
+  if ($ instanceof Ok) {
+    skill_content = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      744,
+      "check_dependencies_missing_dep_warns_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 28885,
+        end: 28979,
+        pattern_start: 28896,
+        pattern_end: 28913
+      }
+    )
+  }
+  let $1 = $skillc.run(toList(["check", "test/fixtures/skill-with-deps"]));
+  if (!($1 instanceof Ok)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      746,
+      "check_dependencies_missing_dep_warns_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 28982,
+        end: 29055,
+        pattern_start: 28993,
+        pattern_end: 28998
+      }
+    )
+  }
+  let $2 = $parser.parse_skill_yaml(skill_content);
+  let parsed_skill;
+  if ($2 instanceof Ok) {
+    parsed_skill = $2[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      748,
+      "check_dependencies_missing_dep_warns_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $2,
+        start: 29141,
+        end: 29213,
+        pattern_start: 29152,
+        pattern_end: 29168
+      }
+    )
+  }
+  let output_dir = "/tmp/skillc-test-dep-check";
+  let $3 = $simplifile.delete$(output_dir);
+  
+  let $4 = $simplifile.create_directory_all(output_dir);
+  if (!($4 instanceof Ok)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      752,
+      "check_dependencies_missing_dep_warns_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $4,
+        start: 29304,
+        end: 29366,
+        pattern_start: 29315,
+        pattern_end: 29320
+      }
+    )
+  }
+  let warnings = $compiler.check_dependencies(parsed_skill, output_dir);
+  $should.equal($list.length(warnings), 1);
+  let dep;
+  if (warnings instanceof $Empty) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      755,
+      "check_dependencies_missing_dep_warns_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: warnings,
+        start: 29481,
+        end: 29533,
+        pattern_start: 29492,
+        pattern_end: 29522
+      }
+    )
+  } else {
+    let $5 = warnings.head;
+    if ($5 instanceof $types.MissingDependency) {
+      let $6 = warnings.tail;
+      if ($6 instanceof $Empty) {
+        dep = $5.dependency;
+      } else {
+        throw makeError(
+          "let_assert",
+          FILEPATH,
+          "compiler_test",
+          755,
+          "check_dependencies_missing_dep_warns_test",
+          "Pattern match failed, no pattern matched the value.",
+          {
+            value: warnings,
+            start: 29481,
+            end: 29533,
+            pattern_start: 29492,
+            pattern_end: 29522
+          }
+        )
+      }
+    } else {
+      throw makeError(
+        "let_assert",
+        FILEPATH,
+        "compiler_test",
+        755,
+        "check_dependencies_missing_dep_warns_test",
+        "Pattern match failed, no pattern matched the value.",
+        {
+          value: warnings,
+          start: 29481,
+          end: 29533,
+          pattern_start: 29492,
+          pattern_end: 29522
+        }
+      )
+    }
+  }
+  $should.equal(dep.name, "helper-skill");
+  let $7 = $simplifile.delete$(output_dir);
+  
+  return undefined;
+}
+
+export function check_dependencies_optional_not_warned_test() {
+  let $ = $simplifile.read("test/fixtures/skill-with-deps/skill.yaml");
+  let skill_content;
+  if ($ instanceof Ok) {
+    skill_content = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      762,
+      "check_dependencies_optional_not_warned_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 29681,
+        end: 29775,
+        pattern_start: 29692,
+        pattern_end: 29709
+      }
+    )
+  }
+  let $1 = $parser.parse_skill_yaml(skill_content);
+  let skill;
+  if ($1 instanceof Ok) {
+    skill = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      764,
+      "check_dependencies_optional_not_warned_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 29778,
+        end: 29839,
+        pattern_start: 29789,
+        pattern_end: 29798
+      }
+    )
+  }
+  let output_dir = "/tmp/skillc-test-dep-optional";
+  let $2 = $simplifile.delete$(output_dir);
+  
+  let $3 = $simplifile.create_directory_all(output_dir);
+  if (!($3 instanceof Ok)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      767,
+      "check_dependencies_optional_not_warned_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $3,
+        start: 29933,
+        end: 29995,
+        pattern_start: 29944,
+        pattern_end: 29949
+      }
+    )
+  }
+  let warnings = $compiler.check_dependencies(skill, output_dir);
+  let names = $list.map(
+    warnings,
+    (w) => {
+      if (w instanceof $types.MissingDependency) {
+        let dep = w.dependency;
+        return dep.name;
+      } else {
+        return "";
+      }
+    },
+  );
+  $should.be_false($list.contains(names, "optional-skill"));
+  let $4 = $simplifile.delete$(output_dir);
+  
+  return undefined;
+}
+
+export function check_dependencies_present_dep_no_warn_test() {
+  let $ = $simplifile.read("test/fixtures/skill-with-deps/skill.yaml");
+  let skill_content;
+  if ($ instanceof Ok) {
+    skill_content = $[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      782,
+      "check_dependencies_present_dep_no_warn_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $,
+        start: 30424,
+        end: 30518,
+        pattern_start: 30435,
+        pattern_end: 30452
+      }
+    )
+  }
+  let $1 = $parser.parse_skill_yaml(skill_content);
+  let skill;
+  if ($1 instanceof Ok) {
+    skill = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      784,
+      "check_dependencies_present_dep_no_warn_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 30521,
+        end: 30582,
+        pattern_start: 30532,
+        pattern_end: 30541
+      }
+    )
+  }
+  let output_dir = "/tmp/skillc-test-dep-present";
+  let $2 = $simplifile.delete$(output_dir);
+  
+  let dep_dir = output_dir + "/openclaw/helper-skill";
+  let $3 = $simplifile.create_directory_all(dep_dir);
+  if (!($3 instanceof Ok)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      789,
+      "check_dependencies_present_dep_no_warn_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $3,
+        start: 30767,
+        end: 30826,
+        pattern_start: 30778,
+        pattern_end: 30783
+      }
+    )
+  }
+  let $4 = $simplifile.write(
+    dep_dir + "/SKILL.md",
+    "---\nname: helper-skill\n---\n",
+  );
+  if (!($4 instanceof Ok)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      790,
+      "check_dependencies_present_dep_no_warn_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $4,
+        start: 30829,
+        end: 30926,
+        pattern_start: 30840,
+        pattern_end: 30845
+      }
+    )
+  }
+  let warnings = $compiler.check_dependencies(skill, output_dir);
+  $should.equal(warnings, toList([]));
+  let $5 = $simplifile.delete$(output_dir);
+  
+  return undefined;
+}
+
+export function compile_with_deps_shows_warning_test() {
+  let output_dir = "/tmp/skillc-test-compile-deps";
+  let $ = $simplifile.delete$(output_dir);
+  
+  let $1 = $skillc.run(
+    toList(["compile", "test/fixtures/skill-with-deps", "--output", output_dir]),
+  );
+  let output;
+  if ($1 instanceof Ok) {
+    output = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      801,
+      "compile_with_deps_shows_warning_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 31210,
+        end: 31349,
+        pattern_start: 31221,
+        pattern_end: 31231
+      }
+    )
+  }
+  $should.be_true($string.contains(output, "helper-skill"));
+  $should.be_true($string.contains(output, "Warning"));
+  let $2 = $simplifile.delete$(output_dir);
+  
+  return undefined;
+}
+
+export function emit_openclaw_no_openai_yaml_test() {
+  let output_dir = "/tmp/skillc-test-no-codex-yaml";
+  let $ = $simplifile.delete$(output_dir);
+  
+  let $1 = $compiler.compile("test/fixtures/valid-skill", "openclaw");
+  let compiled;
+  if ($1 instanceof Ok) {
+    compiled = $1[0];
+  } else {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      818,
+      "emit_openclaw_no_openai_yaml_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $1,
+        start: 31650,
+        end: 31737,
+        pattern_start: 31661,
+        pattern_end: 31673
+      }
+    )
+  }
+  let $2 = $compiler.emit(compiled, output_dir, "test-skill");
+  if (!($2 instanceof Ok)) {
+    throw makeError(
+      "let_assert",
+      FILEPATH,
+      "compiler_test",
+      820,
+      "emit_openclaw_no_openai_yaml_test",
+      "Pattern match failed, no pattern matched the value.",
+      {
+        value: $2,
+        start: 31740,
+        end: 31808,
+        pattern_start: 31751,
+        pattern_end: 31756
+      }
+    )
+  }
+  let yaml_path = output_dir + "/openclaw/test-skill/agents/openai.yaml";
+  $should.be_true(!isEqual($simplifile.is_file(yaml_path), new Ok(true)));
+  let $3 = $simplifile.delete$(output_dir);
+  
+  return undefined;
+}