agent-valley 2.2.1 → 2.3.0

package/dist/index.js

@@ -6439,6 +6439,72 @@ var init_zod = __esm(() => {
   init_external();
 });
 
+// ../../packages/core/src/oma/skill-matrix-schema.ts
+var hash, name, bounded, path, skillCompatibilityConfigSchema, skillCompatibilityPolicySchema, omaConfigSchema, matrixSkillSchema, matrixReportSchema;
+var init_skill_matrix_schema = __esm(() => {
+  init_zod();
+  hash = string2().regex(/^[a-f0-9]{64}$/);
+  name = string2().regex(/^[a-z0-9][a-z0-9-]{0,127}$/);
+  bounded = string2().trim().min(1).max(2000);
+  path = string2().min(1).max(4096).refine((value) => !value.includes("\x00"));
+  skillCompatibilityConfigSchema = strictObject({
+    report_path: path,
+    max_age_hours: number2().finite().positive().max(8760).default(168),
+    mode: _enum(["warn", "require"])
+  });
+  skillCompatibilityPolicySchema = strictObject({
+    reportPath: path,
+    maxAgeHours: number2().finite().positive().max(8760),
+    mode: _enum(["warn", "require"])
+  });
+  omaConfigSchema = strictObject({
+    mode: _enum(["off", "strict"]).default("off"),
+    skill_compatibility: skillCompatibilityConfigSchema.optional()
+  });
+  matrixSkillSchema = object({
+    name,
+    hash,
+    caseId: bounded,
+    requiredFiles: array(path).min(1).max(500),
+    missingFiles: array(path).max(500),
+    excludedReferences: array(object({ path, reason: bounded })).max(500)
+  });
+  matrixReportSchema = object({
+    schemaVersion: literal(1),
+    kind: literal("skill-compatibility-matrix"),
+    mode: _enum(["plan", "live"]),
+    status: _enum(["planned", "completed", "cancelled", "interrupted"]),
+    createdAt: exports_iso.datetime(),
+    omaVersion: bounded,
+    host: object({ platform: bounded, arch: bounded, node: bounded }),
+    suiteHash: hash,
+    sourceKind: _enum(["synthetic", "installed"]),
+    delivery: _enum(["native", "injected"]),
+    auditScope: _enum(["fixture-contract", "read-reference"]),
+    protocolVersion: literal("oma-skill-matrix-v2"),
+    bundle: object({ hash, skills: array(matrixSkillSchema).min(1).max(100) }).optional(),
+    cases: array(object({ id: bounded, skill: name })).max(100),
+    models: object({ claude: bounded.nullable(), codex: bounded.nullable() }),
+    cells: array(object({
+      caseId: bounded,
+      skill: name,
+      vendor: _enum(["claude", "codex"]),
+      status: _enum(["pass", "fail", "unverifiable", "error"]),
+      contentHash: hash,
+      checks: array(object({
+        id: bounded,
+        status: _enum(["pass", "fail", "unverifiable"]),
+        detail: bounded,
+        proof: _enum(["read", "canary"]).optional()
+      })).max(1000),
+      nativeActivation: _enum(["observed", "unobserved"]),
+      cliVersion: string2().regex(/^[\w .()+/-]{1,160}$/).nullable(),
+      model: bounded.nullable(),
+      durationMs: number2().finite().nonnegative()
+    })).max(200)
+  });
+});
+
 // ../../packages/core/src/config/task-schema.ts
 var reportPath, taskSchema, resolvedTaskSchema;
 var init_task_schema = __esm(() => {
@@ -6896,6 +6962,7 @@ var init_execution = __esm(() => {
 var actorType, text, amount, routingCandidateSchema, chiefOperatingPolicySchema, operatingRunSchema, routeEvidenceSchema, reviewDecisionSchema, chiefOperationsSchema;
 var init_operations = __esm(() => {
   init_zod();
+  init_skill_matrix_schema();
   actorType = string2().regex(/^[a-z0-9][a-z0-9-]{0,127}$/);
   text = string2().trim().min(1).max(2000);
   amount = number2().finite().nonnegative();
@@ -6914,6 +6981,7 @@ var init_operations = __esm(() => {
     reviewVendor: _enum(["prefer", "require", "off"]),
     readyActors: array(actorType).max(20).optional(),
     memory: boolean2(),
+    skillCompatibility: skillCompatibilityPolicySchema.optional(),
     metricTargets: array(strictObject({
       name: text,
       unit: text.optional(),
@@ -7232,7 +7300,7 @@ function chiefExecutionPolicy(config) {
     autoResume: execution.auto_resume
   } : {});
 }
-function chiefOperatingPolicy(config, readyActors, automatic = true) {
+function chiefOperatingPolicy(config, readyActors, automatic = true, skillCompatibility) {
   return chiefOperatingPolicySchema.parse({
     routing: config.routing ? {
       candidates: config.routing.candidates.map((item) => ({
@@ -7247,7 +7315,8 @@ function chiefOperatingPolicy(config, readyActors, automatic = true) {
     reviewVendor: config.review_vendor ?? "prefer",
     memory: config.memory ?? true,
     metricTargets: config.metric_targets,
-    readyActors
+    readyActors,
+    skillCompatibility
   });
 }
 function chiefCapturePolicy(config) {
@@ -14575,7 +14644,7 @@ function mergeConfigs(global2, project, env) {
     tunnel: buildTunnelConfig(project),
     verify: buildVerifyConfig(project),
     task: project?.task?.kind === "analysis" ? { kind: "analysis", reportPath: project.task.report_path } : { kind: "code" },
-    oma: { mode: project?.oma?.mode ?? "off" },
+    oma: project?.oma ?? { mode: "off" },
     chief: global2?.chief || project?.chief ? mergeChiefConfig(global2?.chief, project?.chief) : undefined
   };
 }
@@ -14613,6 +14682,7 @@ Symphony cannot start until all config errors are resolved.`);
 var globalConfigSchema, projectConfigSchema, githubConfigSchema, mergedConfigSchema;
 var init_yaml_loader = __esm(() => {
   init_zod();
+  init_skill_matrix_schema();
   init_actor_schema();
   init_budget_schema();
   init_chief_schema();
@@ -14706,7 +14776,7 @@ var init_yaml_loader = __esm(() => {
     tunnel: tunnelProjectSchema,
     verify: verifyProjectSchema,
     task: taskSchema.optional(),
-    oma: object({ mode: _enum(["off", "strict"]).default("off") }).optional(),
+    oma: omaConfigSchema.optional(),
     chief: chiefConfigSchema.optional()
   }).strict().overwrite(normalizeActorDefaults);
   githubConfigSchema = object({
@@ -14775,7 +14845,7 @@ var init_yaml_loader = __esm(() => {
     tunnel: tunnelMergedSchema,
     verify: verifyMergedSchema,
     task: resolvedTaskSchema.optional(),
-    oma: object({ mode: _enum(["off", "strict"]) }).optional(),
+    oma: omaConfigSchema.optional(),
     chief: chiefConfigSchema.optional()
   }).superRefine((cfg, ctx) => {
     if (cfg.trackerKind === "linear") {
@@ -20724,7 +20794,7 @@ var init_readdirp = __esm(() => {
 
 // ../../node_modules/.bun/chokidar@5.0.0/node_modules/chokidar/handler.js
 import { watch as fs_watch, unwatchFile, watchFile } from "node:fs";
-import { realpath as fsrealpath, lstat as lstat18, open as open11, stat as stat4 } from "node:fs/promises";
+import { realpath as fsrealpath, lstat as lstat18, open as open12, stat as stat4 } from "node:fs/promises";
 import { type as osType } from "node:os";
 import * as sp from "node:path";
 function createFsWatchInstance(path, options, listener, errHandler, emitRaw) {
@@ -21066,7 +21136,7 @@ var STR_DATA = "data", STR_END = "end", STR_CLOSE = "close", EMPTY_FN = () => {}
         cont.watcherUnusable = true;
       if (isWindows && error.code === "EPERM") {
         try {
-          const fd = await open11(path, "r");
+          const fd = await open12(path, "r");
           await fd.close();
           broadcastErr(error);
         } catch (err) {}
@@ -22699,7 +22769,7 @@ var init_agent_provisioning = __esm(() => {
 import { mkdtempSync as mkdtempSync2, rmSync as rmSync3 } from "node:fs";
 import { chmod as chmod4, lstat as lstat19, readdir as readdir12, readFile as readFile16, realpath as realpath25, unlink as unlink8, writeFile as writeFile14 } from "node:fs/promises";
 import { homedir as homedir8, tmpdir as tmpdir5 } from "node:os";
-import { delimiter as delimiter4, isAbsolute as isAbsolute15, join as join47, relative as relative14, resolve as resolve27 } from "node:path";
+import { delimiter as delimiter4, isAbsolute as isAbsolute15, join as join47, relative as relative14, resolve as resolve28 } from "node:path";
 function defaults2() {
   const home = homedir8();
   return {
@@ -22773,7 +22843,7 @@ async function restoreConfig(agents, snapshots) {
 async function workspacePath(input) {
   if (!input.trim() || !isAbsolute15(input))
     return null;
-  const root = resolve27(input);
+  const root = resolve28(input);
   if (!await directory2(root))
     return null;
   for (const path of [join47(root, ".agents"), join47(root, ".agents", "skills")]) {
@@ -24399,7 +24469,7 @@ var init_workspace_step = __esm(() => {
 
 // src/setup/noninteractive-config.ts
 import { lstat as lstat20, realpath as realpath26 } from "node:fs/promises";
-import { isAbsolute as isAbsolute17, join as join48, parse as parsePath, resolve as resolve28 } from "node:path";
+import { isAbsolute as isAbsolute17, join as join48, parse as parsePath, resolve as resolve29 } from "node:path";
 function validateNoninteractiveOptions(options) {
   if (!options.yes || options.edit || options.mode !== undefined && options.mode !== "order")
     throw new Error("Use av setup --yes only for local order setup; --edit and --mode tracker require interactive setup.");
@@ -24480,13 +24550,13 @@ async function prepareNoninteractiveConfig(options, deps) {
   validateNoninteractiveOptions(options);
   let projectRoot;
   try {
-    projectRoot = await realpath26(resolve28(deps.projectRoot));
+    projectRoot = await realpath26(resolve29(deps.projectRoot));
     if (!(await lstat20(projectRoot)).isDirectory())
       throw new Error("not a directory");
   } catch {
     throw new Error(`AV configuration directory ${deps.projectRoot} does not exist. Run av setup from an existing directory.`);
   }
-  const globalPath = resolve28(deps.globalConfigPath);
+  const globalPath = resolve29(deps.globalConfigPath);
   const projectPath = join48(projectRoot, "av.yaml");
   const project = await configFile(projectPath, projectConfigSchema);
   const global2 = await configFile(globalPath, globalConfigSchema);
@@ -24504,7 +24574,7 @@ async function prepareNoninteractiveConfig(options, deps) {
   }
   const savedWorkspace = project.raw.workspace?.root;
   const selectedWorkspace = options.workspace ?? savedWorkspace ?? projectRoot;
-  const workspacePath = isAbsolute17(selectedWorkspace) ? selectedWorkspace : resolve28(projectRoot, selectedWorkspace);
+  const workspacePath = isAbsolute17(selectedWorkspace) ? selectedWorkspace : resolve29(projectRoot, selectedWorkspace);
   const workspaceError = await validateOrderWorkspace(workspacePath);
   if (workspaceError)
     throw new Error(workspaceError);
@@ -24539,7 +24609,7 @@ var init_noninteractive_config = __esm(() => {
 });
 
 // src/setup/noninteractive.ts
-import { join as join49, parse as parsePath2, resolve as resolve29 } from "node:path";
+import { join as join49, parse as parsePath2, resolve as resolve30 } from "node:path";
 function rerunCommand(result, options) {
   const quote = (value) => `'${value.replace(/'/g, "'\\''")}'`;
   return `cd ${quote(result.projectRoot)} && av setup --yes --actor ${result.chief.actorType} --model ${quote(result.chief.model ?? "")} --workspace ${quote(result.workspace ?? result.projectRoot)} --oma ${options.oma ?? "prepare"} --json`;
@@ -24550,11 +24620,11 @@ async function setupNoninteractive(options, overrides = {}) {
     version: 1,
     status: "failed",
     exitCode: 1,
-    projectRoot: resolve29(deps.projectRoot),
+    projectRoot: resolve30(deps.projectRoot),
     workspace: null,
     config: {
-      project: join49(resolve29(deps.projectRoot), "av.yaml"),
-      global: resolve29(deps.globalConfigPath),
+      project: join49(resolve30(deps.projectRoot), "av.yaml"),
+      global: resolve30(deps.globalConfigPath),
       saved: false
     },
     chief: {
@@ -25127,18 +25197,18 @@ async function stepMetrics(ctx) {
       draft.file = file;
     }
     for (const field of ["value_path", "timestamp_path", "unit_path"]) {
-      const value = await text12(`JSON ${field}`, old?.[field] ?? field.replace("_path", ""), path3);
+      const value = await text12(`JSON ${field}`, old?.[field] ?? field.replace("_path", ""), path4);
       if (navigated2(value))
         return value;
       draft[field] = value;
     }
-    const start = await text12("JSON measurement window start path (optional; blank omits window)", old?.window_start_path ?? "", (value) => value ? path3(value) : undefined);
+    const start = await text12("JSON measurement window start path (optional; blank omits window)", old?.window_start_path ?? "", (value) => value ? path4(value) : undefined);
     if (navigated2(start))
       return start;
     delete draft.window_start_path;
     delete draft.window_end_path;
     if (start) {
-      const end = await text12("JSON measurement window end path", old?.window_end_path ?? "window.end", path3);
+      const end = await text12("JSON measurement window end path", old?.window_end_path ?? "window.end", path4);
       if (navigated2(end))
         return end;
       draft.window_start_path = start;
@@ -25184,7 +25254,7 @@ async function stepMetrics(ctx) {
   ctx.chiefChanged = true;
   log2.info("Metric settings are saved after confirmation. Measurements are collected at mission runtime; setup does not contact the source. Set --duration or chief.execution.max_duration_sec long enough for work and the full measurement/observation windows. The default mission limit is 86400 seconds including waits; Stripe's default measurement window is also 86400 seconds.");
 }
-var envName3 = (value) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(value), navigated2 = (value) => typeof value !== "string", required2 = (limit) => (value) => value && value.length <= limit ? undefined : `Enter 1 to ${limit} characters.`, environment = (optional = false) => (value) => optional && !value || envName3(value) ? undefined : "Enter an environment variable name, never a token or URL.", number4 = (minimum, maximum) => (value) => value && Number.isInteger(Number(value)) && Number(value) >= minimum && Number(value) <= maximum ? undefined : `Enter a whole number from ${minimum} to ${maximum}.`, path3 = (value) => {
+var envName3 = (value) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(value), navigated2 = (value) => typeof value !== "string", required2 = (limit) => (value) => value && value.length <= limit ? undefined : `Enter 1 to ${limit} characters.`, environment = (optional = false) => (value) => optional && !value || envName3(value) ? undefined : "Enter an environment variable name, never a token or URL.", number4 = (minimum, maximum) => (value) => value && Number.isInteger(Number(value)) && Number(value) >= minimum && Number(value) <= maximum ? undefined : `Enter a whole number from ${minimum} to ${maximum}.`, path4 = (value) => {
   const result = metricSourceSchema.shape.value_path.safeParse(value);
   return result.success ? undefined : "Use dot-separated JSON keys or array indexes, without prototype keys.";
 };
@@ -27762,7 +27832,7 @@ init_project_config_path();
 init_yaml_loader();
 import { spawn as spawn24, spawnSync as spawnSync5 } from "node:child_process";
 import { existsSync as existsSync10, unlinkSync as unlinkSync2 } from "node:fs";
-import { resolve as resolve30 } from "node:path";
+import { resolve as resolve31 } from "node:path";
 
 // ../../packages/core/src/version.ts
 import { readFileSync as readFileSync2 } from "node:fs";
@@ -27872,7 +27942,7 @@ function humanReadableArgName(arg) {
 // ../../node_modules/.bun/commander@15.0.0/node_modules/commander/lib/command.js
 import { EventEmitter } from "node:events";
 import childProcess from "node:child_process";
-import path from "node:path";
+import path2 from "node:path";
 import fs from "node:fs";
 import process2 from "node:process";
 import { stripVTControlCharacters as stripVTControlCharacters2 } from "node:util";
@@ -29016,10 +29086,10 @@ Expecting one of '${allowedValues.join("', '")}'`);
     args = args.slice();
     const sourceExt = [".js", ".ts", ".tsx", ".mjs", ".cjs"];
     function findFile(baseDir, baseName) {
-      const localBin = path.resolve(baseDir, baseName);
+      const localBin = path2.resolve(baseDir, baseName);
       if (fs.existsSync(localBin))
         return localBin;
-      if (sourceExt.includes(path.extname(baseName)))
+      if (sourceExt.includes(path2.extname(baseName)))
         return;
       const foundExt = sourceExt.find((ext) => fs.existsSync(`${localBin}${ext}`));
       if (foundExt)
@@ -29037,19 +29107,19 @@ Expecting one of '${allowedValues.join("', '")}'`);
       } catch {
         resolvedScriptPath = this._scriptPath;
       }
-      executableDir = path.resolve(path.dirname(resolvedScriptPath), executableDir);
+      executableDir = path2.resolve(path2.dirname(resolvedScriptPath), executableDir);
     }
     if (executableDir) {
       let localFile = findFile(executableDir, executableFile);
       if (!localFile && !subcommand._executableFile && this._scriptPath) {
-        const legacyName = path.basename(this._scriptPath, path.extname(this._scriptPath));
+        const legacyName = path2.basename(this._scriptPath, path2.extname(this._scriptPath));
         if (legacyName !== this._name) {
           localFile = findFile(executableDir, `${legacyName}-${subcommand._name}`);
         }
       }
       executableFile = localFile || executableFile;
     }
-    const launchWithNode = sourceExt.includes(path.extname(executableFile));
+    const launchWithNode = sourceExt.includes(path2.extname(executableFile));
     let proc;
     if (process2.platform !== "win32") {
       if (launchWithNode) {
@@ -29640,13 +29710,13 @@ Expecting one of '${allowedValues.join("', '")}'`);
       cmd.helpGroup(this._defaultCommandGroup);
   }
   nameFromFilename(filename) {
-    this._name = path.basename(filename, path.extname(filename));
+    this._name = path2.basename(filename, path2.extname(filename));
     return this;
   }
-  executableDir(path2) {
-    if (path2 === undefined)
+  executableDir(path) {
+    if (path === undefined)
       return this._executableDir;
-    this._executableDir = path2;
+    this._executableDir = path;
     return this;
   }
   helpInformation(contextOptions) {
@@ -48938,7 +49008,7 @@ var sha256 = string2().regex(/^[a-f0-9]{64}$/);
 function safeVerificationPath(path) {
   return path.length > 0 && path.length <= 1024 && !isAbsolute2(path) && !/^[a-z]:/i.test(path) && !/[\\\0\r\n]/.test(path) && path.split("/").every((part) => part !== "" && part !== "." && part !== "..") && !/^(?:\.git(?:\/|$)|\.agent-valley(?:\/|$)|\.agents\/(?:state|results)(?:\/|$))/.test(path);
 }
-var path2 = string2().refine(safeVerificationPath, "Use a literal relative product path inside the worktree.");
+var path3 = string2().refine(safeVerificationPath, "Use a literal relative product path inside the worktree.");
 var testPath = (name, nodeOnly = false) => safeVerificationPath(name) && !name.startsWith("-") && !/[*?{}]/.test(name) && !name.startsWith("node_modules/") && (nodeOnly ? /(?:\.test|\.spec)\.(?:js|mjs|cjs)$/ : /(?:\.test|\.spec)\.(?:[cm]?[jt]sx?)$/).test(name);
 function verificationCommandTestPaths(program, args) {
   if (program === "bun" && args[0] === "test")
@@ -48975,14 +49045,14 @@ function safeVerificationCommand(program, args) {
 var goalVerificationCheckSchema = discriminatedUnion("kind", [
   strictObject({
     kind: literal("file"),
-    path: path2,
+    path: path3,
     minBytes: number2().int().min(1).max(4194304).default(1),
     contains: array(text4).min(1).max(10).optional(),
     sha256: sha256.optional()
   }),
   strictObject({
     kind: literal("json"),
-    path: path2,
+    path: path3,
     pointer: string2().max(1024).refine((value) => value === "" || /^(?:\/(?:[^~]|~[01])*)+$/.test(value), {
       message: "Use an RFC 6901 JSON pointer such as /engines/node."
     }),
@@ -49444,16 +49514,29 @@ function routeEvidence(mission) {
 function price2(candidate) {
   return candidate.inputPerMillionUsd !== undefined && candidate.outputPerMillionUsd !== undefined ? candidate.inputPerMillionUsd + candidate.outputPerMillionUsd : Number.POSITIVE_INFINITY;
 }
-function selectWorkActor(mission, actor, taskId) {
+function workActorCandidates(mission, actor, preserveExplicit = false) {
   const routing = mission.operatingPolicy?.routing;
-  if (!routing || actor.id === mission.chiefId || !mission.availableAgents && actor.model)
+  if (!routing || actor.id === mission.chiefId || !mission.availableAgents && (actor.model || preserveExplicit))
+    return [{ actorType: actor.agentType, model: actor.model }];
+  const ready = mission.operatingPolicy?.readyActors ?? mission.availableAgents ?? [];
+  return routing.candidates.filter((candidate) => ready.includes(candidate.actorType));
+}
+function selectWorkActor(mission, actor, taskId, compatibleRoutes) {
+  const routing = mission.operatingPolicy?.routing;
+  if (!routing || actor.id === mission.chiefId || !mission.availableAgents && (actor.model || compatibleRoutes)) {
+    if (compatibleRoutes && !compatibleRoutes.has(routeKey({ actorType: actor.agentType, model: actor.model })))
+      throw new Error("Skill compatibility required: the configured Actor/model has no current passing evidence. Refresh oma.skill_compatibility.report_path in av.yaml; explicit Actors are not rerouted.");
     return { actor, reason: "Preserved the configured Actor and explicit model." };
+  }
   const ready = mission.operatingPolicy?.readyActors ?? mission.availableAgents ?? [];
   const candidates = routing.candidates.filter((candidate) => ready.includes(candidate.actorType));
   if (!candidates.length)
     throw new Error("No configured work routing candidate is ready. Install/login a candidate CLI or update chief.routing.candidates in av.yaml.");
+  const compatible = compatibleRoutes ? candidates.filter((candidate) => compatibleRoutes.has(routeKey(candidate))) : candidates;
+  if (!compatible.length)
+    throw new Error("Skill compatibility required: no ready work candidate has current passing installed evidence. Refresh oma.skill_compatibility.report_path in av.yaml with explicit models before retrying.");
   const evidence = routeEvidence(mission);
-  const eligible = candidates.filter((candidate) => {
+  const eligible = compatible.filter((candidate) => {
     const observed = evidence.find((item) => routeKey(item) === routeKey(candidate));
     return !observed || observed.samples < routing.minSamples || observed.successes / observed.samples >= routing.minSuccessRate;
   });
@@ -49515,6 +49598,10 @@ function operationsEvidence(mission) {
     pricingBasis: "Estimates from configured input/output prices and actual adapter-reported tokens; excludes unreported cache/reasoning/subagent usage and subscription billing.",
     routeQuality: routeEvidence(mission).slice(0, 20),
     reviewPolicy: mission.operatingPolicy?.reviewVendor ?? "legacy independent Actor",
+    skillCompatibility: mission.operatingPolicy?.skillCompatibility ? {
+      mode: mission.operatingPolicy.skillCompatibility.mode,
+      recentChecks: mission.history.filter((entry) => entry.stage === "skill-compatibility").slice(-10)
+    } : undefined,
     recentRuns: runs.slice(-20),
     crossVendorReviews: mission.operations?.reviewDecisions.slice(-20) ?? [],
     organizationContext: mission.organizationContext,
@@ -49530,6 +49617,10 @@ function operationsReportLines(mission) {
     `기록된 token·설정 단가 기반 부분 비용 추정 USD ${evidence.knownEstimatedCostUsd.toFixed(6)} / 비용 미확인 ${evidence.unknownCostRuns}회 / 전체 추정 ${evidence.totalEstimatedCostUsd === null ? "미확인" : `USD ${evidence.totalEstimatedCostUsd.toFixed(6)}`}`,
     `최근 독립 리뷰 배정: 다른 vendor ${evidence.crossVendorReviews.filter((review) => review.crossVendor).length}회 / 동일 vendor fallback ${evidence.crossVendorReviews.filter((review) => !review.crossVendor).length}회 / 실제 리뷰 통과 ${evidence.crossVendorReviews.filter((review) => review.outcome === "passed").length}회`,
     `vendor 리뷰 정책: ${evidence.reviewPolicy}`,
+    ...evidence.skillCompatibility ? [
+      `OMA 스킬 읽기·참조 정책: ${evidence.skillCompatibility.mode}; AV 실행 환경 또는 작업 품질 인증이 아닙니다.`,
+      ...evidence.skillCompatibility.recentChecks.map((entry) => `${entry.at}: ${entry.message}`)
+    ] : [],
     ...mission.organizationContext ? [
       `계획·리뷰에 제공한 조직 근거: 승인 memory ${mission.organizationContext.memories.length}개 / 과거 outcome ${mission.organizationContext.outcomes.length}개 / 기록된 metric sample ${mission.organizationContext.metrics.length}개`
     ] : [],
@@ -49557,15 +49648,15 @@ var chiefReportSchema = strictObject({
   checks: entries,
   remaining: entries
 });
-function bounded(value, limit = 500) {
+function bounded2(value, limit = 500) {
   const content = value.trim();
   return content.length <= limit ? content : `${content.slice(0, limit - 8)}… [생략]`;
 }
 function compact(values, limit = 20) {
   if (values.length <= limit)
-    return values.map((value) => bounded(value)).filter(Boolean);
+    return values.map((value) => bounded2(value)).filter(Boolean);
   return [
-    ...values.slice(0, limit - 1).map((value) => bounded(value)).filter(Boolean),
+    ...values.slice(0, limit - 1).map((value) => bounded2(value)).filter(Boolean),
     `${values.length - limit + 1}개 항목 생략`
   ];
 }
@@ -49580,7 +49671,7 @@ function criteria(mission) {
 function incompleteReasons(mission) {
   const reasons = [];
   if (mission.error)
-    reasons.push(`${["waiting", "paused"].includes(mission.status) ? "대기·중단 이유" : "실패 원인"}: ${bounded(mission.error, 450)}`);
+    reasons.push(`${["waiting", "paused"].includes(mission.status) ? "대기·중단 이유" : "실패 원인"}: ${bounded2(mission.error, 450)}`);
   if (mission.status !== "completed")
     reasons.push(`미션 상태: ${mission.status}. 완료 판정이 없습니다.`);
   if (!mission.verification)
@@ -49633,33 +49724,33 @@ function incompleteReasons(mission) {
 }
 function decisionEvidence(mission) {
   const actions = { repair: "수정", reassign: "담당 교체", replan: "재계획", wait: "대기", stop: "중단" };
-  return (mission.supervision?.decisions ?? []).slice(-20).map((decision) => bounded(`${decision.round}차 ${actions[decision.action]}${decision.taskId ? ` / 작업 ${decision.taskId}` : ""}${decision.personaId ? ` / 담당 ${decision.personaId}` : ""}: ${decision.reason}`));
+  return (mission.supervision?.decisions ?? []).slice(-20).map((decision) => bounded2(`${decision.round}차 ${actions[decision.action]}${decision.taskId ? ` / 작업 ${decision.taskId}` : ""}${decision.personaId ? ` / 담당 ${decision.personaId}` : ""}: ${decision.reason}`));
 }
 function reviewEvidence(review) {
   return review ? {
     passed: review.passed,
-    summary: bounded(review.summary),
+    summary: bounded2(review.summary),
     findings: compact(review.findings),
     criteria: review.criteria?.slice(0, 20).map((item) => ({
-      criterion: bounded(item.criterion),
+      criterion: bounded2(item.criterion),
       passed: item.passed,
-      evidence: bounded(item.evidence)
+      evidence: bounded2(item.evidence)
     }))
   } : undefined;
 }
 function verificationEvidence(verification) {
   return verification ? {
     ok: verification.ok,
-    output: verification.output ? bounded(verification.output, 3000) : undefined,
-    fingerprint: bounded(verification.fingerprint, 128)
+    output: verification.output ? bounded2(verification.output, 3000) : undefined,
+    fingerprint: bounded2(verification.fingerprint, 128)
   } : undefined;
 }
 function advisoryEvidence(kind, advisory) {
   return advisory ? {
     kind: `upfront ${kind} advice; historical snapshot; not current approval`,
-    planKey: bounded(advisory.planKey, 128),
+    planKey: bounded2(advisory.planKey, 128),
     reviewerId: advisory.reviewerId,
-    fingerprint: bounded(advisory.fingerprint, 128),
+    fingerprint: bounded2(advisory.fingerprint, 128),
     review: reviewEvidence(advisory.review)
   } : undefined;
 }
@@ -49669,24 +49760,24 @@ function historicalEvidence(mission) {
     const verification = decision.evidence?.verification;
     const review = decision.evidence?.finalReview;
     if (verification)
-      lines.push(bounded(`${decision.round}차 판단 당시 검증: ${verification.ok ? "통과" : "실패"} / 파일 상태 ${bounded(verification.fingerprint, 128)}${verification.output ? ` / ${bounded(verification.output, 250)}` : ""}`));
+      lines.push(bounded2(`${decision.round}차 판단 당시 검증: ${verification.ok ? "통과" : "실패"} / 파일 상태 ${bounded2(verification.fingerprint, 128)}${verification.output ? ` / ${bounded2(verification.output, 250)}` : ""}`));
     if (review) {
-      lines.push(bounded(`${decision.round}차 판단 당시 최종 리뷰: ${review.passed ? "통과" : "실패"} / ${bounded(review.summary, 350)}`));
-      lines.push(...compact(review.findings, 3).map((finding) => bounded(`${decision.round}차 판단 당시 지적: ${finding}`)));
+      lines.push(bounded2(`${decision.round}차 판단 당시 최종 리뷰: ${review.passed ? "통과" : "실패"} / ${bounded2(review.summary, 350)}`));
+      lines.push(...compact(review.findings, 3).map((finding) => bounded2(`${decision.round}차 판단 당시 지적: ${finding}`)));
     }
     return lines;
   });
 }
 function checkEvidence(mission) {
   return compact([
-    `운영자 검증: ${mission.verification ? mission.verification.ok ? "통과" : "실패" : "미실행"} / 명령: ${bounded(mission.supervision?.operatorVerifyCommand ?? mission.verifyCommand, 350)}`,
+    `운영자 검증: ${mission.verification ? mission.verification.ok ? "통과" : "실패" : "미실행"} / 명령: ${bounded2(mission.supervision?.operatorVerifyCommand ?? mission.verifyCommand, 350)}`,
     ...mission.verification?.output ? [`검증 출력: ${mission.verification.output}`] : [],
     `Chief Director 최종 리뷰: ${mission.finalReview ? mission.finalReview.passed && mission.finalReview.findings.length === 0 ? "통과" : "실패" : "미실행"}${mission.finalReview ? ` / ${mission.finalReview.summary}` : ""}`,
     ...mission.tasks.map((task) => `${task.id}: 상태 ${task.status}, 시도 ${task.attempts}회, 독립 리뷰 ${task.review ? task.review.passed && task.review.findings.length === 0 ? "통과" : "실패" : "미실행"} / 리뷰어 ${task.reviewerId}`)
   ]);
 }
 function criterionEvidence(mission) {
-  return (mission.finalReview?.criteria ?? []).map((item) => bounded(`${bounded(item.criterion, 200)}: ${item.passed ? "통과" : "실패"} / 근거: ${bounded(item.evidence, 250)}`));
+  return (mission.finalReview?.criteria ?? []).map((item) => bounded2(`${bounded2(item.criterion, 200)}: ${item.passed ? "통과" : "실패"} / 근거: ${bounded2(item.evidence, 250)}`));
 }
 function reportPrompt(mission) {
   const goal = mission.supervision?.operatorGoal ?? mission.goal;
@@ -49714,8 +49805,8 @@ function reportPrompt(mission) {
     '{"summary":"result","eli5":"plain-language result and user impact","goalAssessment":"criteria and actual verdict","assumptions":[],"decisions":[],"deliverables":[],"checks":[],"remaining":[]}',
     `Report evidence (JSON data):
 ${JSON.stringify({
-      operatorGoal: bounded(goal, 4000),
-      interpretation: mission.goalBrief ? bounded(mission.goalBrief.interpretation, 2000) : undefined,
+      operatorGoal: bounded2(goal, 4000),
+      interpretation: mission.goalBrief ? bounded2(mission.goalBrief.interpretation, 2000) : undefined,
       assumptions: compact(mission.goalBrief?.assumptions ?? []),
       successCriteria: compact(criteria(mission)),
       status: mission.status,
@@ -49724,9 +49815,9 @@ ${JSON.stringify({
       containerObservation: mission.containerObservation,
       verdict: incompleteReasons(mission).length === 0 ? "completed" : "incomplete",
       incompleteReasons: incompleteReasons(mission),
-      error: mission.error ? bounded(mission.error, 2000) : undefined,
-      workspace: bounded(mission.workspace.path, 2000),
-      branch: bounded(mission.workspace.branch),
+      error: mission.error ? bounded2(mission.error, 2000) : undefined,
+      workspace: bounded2(mission.workspace.path, 2000),
+      branch: bounded2(mission.workspace.branch),
       chiefId: mission.chiefId,
       technicalLeadId: mission.technicalLeadId,
       technicalAdvice: advisoryEvidence("technical", mission.technicalReview),
@@ -49736,10 +49827,10 @@ ${JSON.stringify({
       marketingAdvice: advisoryEvidence("marketing", mission.marketingReview),
       actors: mission.personas.slice(0, 20).map((persona) => ({
         id: persona.id,
-        name: bounded(persona.name),
-        role: bounded(persona.role),
-        cli: bounded(persona.agentType),
-        model: persona.model ? bounded(persona.model) : "native default (actual model not recorded)",
+        name: bounded2(persona.name),
+        role: bounded2(persona.role),
+        cli: bounded2(persona.agentType),
+        model: persona.model ? bounded2(persona.model) : "native default (actual model not recorded)",
         selectedSkills: persona.skills.slice(0, 30)
       })),
       decisions: decisions.map((decision) => ({
@@ -49747,8 +49838,8 @@ ${JSON.stringify({
         action: decision.action,
         taskId: decision.taskId,
         actorId: decision.personaId,
-        reason: bounded(decision.reason),
-        instructions: decision.instructions ? bounded(decision.instructions) : undefined,
+        reason: bounded2(decision.reason),
+        instructions: decision.instructions ? bounded2(decision.instructions) : undefined,
         historicalEvidence: decision.evidence && snapshotDecisions.has(decision) ? {
           kind: "evidence at the recovery decision; not current approval",
           finalReview: reviewEvidence(decision.evidence.finalReview),
@@ -49757,25 +49848,25 @@ ${JSON.stringify({
       })),
       tasks: mission.tasks.slice(0, 12).map((state) => ({
         id: state.id,
-        title: bounded(mission.plan?.tasks.find((task) => task.id === state.id)?.title ?? state.id),
+        title: bounded2(mission.plan?.tasks.find((task) => task.id === state.id)?.title ?? state.id),
         actorId: mission.plan?.tasks.find((task) => task.id === state.id)?.personaId,
         reviewerId: state.reviewerId,
         status: state.status,
         attempts: state.attempts,
-        actorClaim: state.output ? bounded(state.output, 3000) : undefined,
+        actorClaim: state.output ? bounded2(state.output, 3000) : undefined,
         review: reviewEvidence(state.review)
       })),
-      verifyCommand: bounded(mission.supervision?.operatorVerifyCommand ?? mission.verifyCommand, 1200),
+      verifyCommand: bounded2(mission.supervision?.operatorVerifyCommand ?? mission.verifyCommand, 1200),
       verification: verificationEvidence(mission.verification),
       goalVerification: mission.goalVerification,
       execution: mission.execution,
       executionPolicy: mission.executionPolicy,
       finalReview: reviewEvidence(mission.finalReview),
       history: mission.history.slice(-30).map((event) => ({
-        at: bounded(event.at),
-        stage: bounded(event.stage),
+        at: bounded2(event.at),
+        stage: bounded2(event.stage),
         taskId: event.taskId,
-        message: bounded(event.message)
+        message: bounded2(event.message)
       }))
     })}`
   ].join(`
@@ -49797,10 +49888,10 @@ function parseReport(source) {
 function fallbackReport(mission) {
   const reasons = incompleteReasons(mission);
   const complete = reasons.length === 0;
-  const goal = bounded(mission.supervision?.operatorGoal ?? mission.goal, 350);
+  const goal = bounded2(mission.supervision?.operatorGoal ?? mission.goal, 350);
   return {
     summary: complete ? "작업, 독립 리뷰, 운영자 검증과 Chief Director 최종 리뷰를 통과했습니다." : "목표는 미완료입니다. 확인된 미해결 조건과 보관된 실행 기록을 보고합니다.",
-    eli5: complete ? `“${goal}”을 위한 결과물을 만들고, 다른 담당자의 점검과 지정한 확인 절차를 마쳤습니다. 결과물은 아래 작업 경로에 보관되어 있어 직접 확인할 수 있습니다.` : `“${goal}”을 위해 작업했지만, 아직 모든 확인 절차를 통과한 결과는 아닙니다. ${bounded(reasons[0] ?? "완료 증거가 없습니다.", 350)} 이미 만든 작업은 보관되어 있습니다. Chief Director가 기록한 판단과 다음 관측·재개 시각, 아직 충족되지 않은 조건을 아래에서 보고합니다.`,
+    eli5: complete ? `“${goal}”을 위한 결과물을 만들고, 다른 담당자의 점검과 지정한 확인 절차를 마쳤습니다. 결과물은 아래 작업 경로에 보관되어 있어 직접 확인할 수 있습니다.` : `“${goal}”을 위해 작업했지만, 아직 모든 확인 절차를 통과한 결과는 아닙니다. ${bounded2(reasons[0] ?? "완료 증거가 없습니다.", 350)} 이미 만든 작업은 보관되어 있습니다. Chief Director가 기록한 판단과 다음 관측·재개 시각, 아직 충족되지 않은 조건을 아래에서 보고합니다.`,
     goalAssessment: complete ? "기록된 성공 기준에 대해 작업별 독립 리뷰와 운영자 검증이 통과했고, Chief Director가 최종 승인했습니다." : "성공 기준 전체의 충족을 확인하지 못했습니다. 일부 작업이나 검증이 통과했더라도 목표 달성으로 표시하지 않습니다.",
     assumptions: compact(mission.goalBrief?.assumptions ?? []),
     decisions: decisionEvidence(mission),
@@ -49818,7 +49909,7 @@ function fallbackReport(mission) {
   };
 }
 function markdown(value, limit = 1200) {
-  return bounded(value, limit).replace(/[\p{Cc}\p{Cf}]/gu, " ").replace(/\s+/g, " ").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/[\\`*_{}[\]()#+.!|~-]/g, "\\$&");
+  return bounded2(value, limit).replace(/[\p{Cc}\p{Cf}]/gu, " ").replace(/\s+/g, " ").replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/[\\`*_{}[\]()#+.!|~-]/g, "\\$&");
 }
 function list(values) {
   return values.length ? compact(values).map((value) => `- ${markdown(value)}`).join(`
@@ -50333,12 +50424,12 @@ async function assertMissionWorkspace(mission) {
 }
 
 // ../../packages/core/src/chief/parallel-workspace.ts
-var hash = (value) => createHash10("sha256").update(value).digest("hex");
+var hash2 = (value) => createHash10("sha256").update(value).digest("hex");
 var same = (a, b) => JSON.stringify(a) === JSON.stringify(b);
 function identity3(missionId, taskId, attempt) {
   if (!taskId || taskId.length > 200 || !Number.isSafeInteger(attempt) || attempt < 1)
     throw new Error("Use a valid task ID and positive attempt number for each parallel Actor.");
-  return `${hash(missionId).slice(0, 16)}-${hash(taskId).slice(0, 16)}-${attempt}`;
+  return `${hash2(missionId).slice(0, 16)}-${hash2(taskId).slice(0, 16)}-${attempt}`;
 }
 async function paths(source, missionId, taskId, attempt) {
   const root = await parallelRoot(source);
@@ -50482,7 +50573,7 @@ async function collectTaskDelivery(mission, workspace) {
     version: 1,
     workspace,
     patchPath: location.patch,
-    patchSha256: hash(patch),
+    patchSha256: hash2(patch),
     deliveryTree: final.tree,
     changes,
     status: "prepared"
@@ -50498,7 +50589,7 @@ async function integrateTaskDelivery(mission, input) {
   if (delivery.workspace.missionId !== mission.id || !same(delivery.workspace, input.workspace) || delivery.patchSha256 !== input.patchSha256 || delivery.patchPath !== location.patch)
     throw new Error("Parallel delivery does not match its persisted task identity and patch. Inspect the saved artifacts before recovery.");
   const patch = await readFile4(location.patch);
-  if (hash(patch) !== delivery.patchSha256)
+  if (hash2(patch) !== delivery.patchSha256)
     throw new Error("Parallel delivery patch changed. Restore its saved SHA256 before integration.");
   const current = await captureParallelBaseline(mission.workspace.path);
   const images = await parallelTreeImages(mission.workspace.path, current.tree);
@@ -66141,7 +66232,11 @@ ${details}` : ""}`);
     timeoutSec,
     maxRepairs,
     maxRounds,
-    operatingPolicy: chiefOperatingPolicy(chiefConfig, readyActors, !profile),
+    operatingPolicy: chiefOperatingPolicy(chiefConfig, readyActors, !profile, project?.oma?.skill_compatibility ? {
+      reportPath: resolve11(root, project.oma.skill_compatibility.report_path),
+      maxAgeHours: project.oma.skill_compatibility.max_age_hours,
+      mode: project.oma.skill_compatibility.mode
+    } : undefined),
     capturePolicy: chiefCapturePolicy(chiefConfig),
     executionPolicy,
     metricSourcePolicy: chiefConfig.metric_sources,
@@ -66676,7 +66771,7 @@ class ContinuousOperationStore {
 }
 
 // src/chief-continuous.ts
-import { execFile as execFile4 } from "node:child_process";
+import { execFile as execFile5 } from "node:child_process";
 import { randomUUID as randomUUID15 } from "node:crypto";
 import { mkdir as mkdir17, realpath as realpath19, rename as rename7, unlink as unlink7, writeFile as writeFile13 } from "node:fs/promises";
 import { join as join35, resolve as resolve19 } from "node:path";
@@ -68307,6 +68402,214 @@ function validateOmaEvidence(request, io = defaultIO2) {
   return { ok: true, runId: String(run.runId) };
 }
 
+// ../../packages/core/src/oma/skill-matrix-adapter.ts
+import { posix } from "node:path";
+
+// ../../packages/core/src/oma/skill-matrix-io.ts
+init_skill_matrix_schema();
+import { execFile as execFile4 } from "node:child_process";
+import { constants as constants5 } from "node:fs";
+import { open as open7 } from "node:fs/promises";
+var MAX_BYTES = 4 * 1024 * 1024;
+async function command(binary, args, signal) {
+  return new Promise((resolve, reject) => {
+    execFile4(binary, args, {
+      encoding: "utf8",
+      timeout: 1e4,
+      maxBuffer: MAX_BYTES,
+      signal,
+      ...binary === "oma" ? { env: { ...process.env, OMA_SKIP_VERSION_CHECK: "1" } } : {}
+    }, (error, stdout) => {
+      if (error)
+        reject(new Error(`${binary} local diagnostic command failed. Check its installation/version and retry.`));
+      else
+        resolve(stdout);
+    });
+  });
+}
+async function readReport(path) {
+  const file = await open7(path, constants5.O_RDONLY | constants5.O_NOFOLLOW | constants5.O_NONBLOCK);
+  try {
+    const info = await file.stat();
+    if (!info.isFile() || info.size > MAX_BYTES)
+      throw new Error("Matrix report must be a regular file at most 4 MiB.");
+    const bytes = Buffer.alloc(info.size + 1);
+    let length = 0;
+    while (length < bytes.length) {
+      const result = await file.read(bytes, length, bytes.length - length, length);
+      if (!result.bytesRead)
+        break;
+      length += result.bytesRead;
+    }
+    if (length !== info.size)
+      throw new Error("Matrix report changed during the read. Retry after its writer finishes.");
+    return JSON.parse(new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, length)));
+  } finally {
+    await file.close();
+  }
+}
+var defaultSkillMatrixDeps = {
+  now: Date.now,
+  platform: process.platform,
+  arch: process.arch,
+  readReport,
+  plan: async (workspace, skills, signal) => JSON.parse(await command("oma", [
+    "skills",
+    "matrix",
+    "--project-root",
+    workspace,
+    "--skills",
+    skills.join(","),
+    "--delivery",
+    "injected",
+    "--vendors",
+    "claude,codex",
+    "--json"
+  ], signal)),
+  cliVersion: async (vendor, signal) => {
+    const version = (await command(vendor, ["--version"], signal)).trim();
+    return /^[\w .()+/-]{1,160}$/.test(version) ? version : null;
+  }
+};
+function parseSkillMatrix(value) {
+  const parsed = matrixReportSchema.safeParse(value);
+  if (!parsed.success)
+    throw new Error("Matrix report uses an unsupported or malformed evidence contract. Regenerate it with the current OMA CLI.");
+  const report = parsed.data;
+  const unique = (values) => new Set(values).size === values.length;
+  if (!unique(report.cases.map((entry) => entry.id)) || !unique(report.cells.map((entry) => `${entry.vendor}\x00${entry.caseId}`)) || report.bundle && (!unique(report.bundle.skills.map((entry) => entry.name)) || !unique(report.bundle.skills.map((entry) => entry.caseId))) || report.cells.some((cell) => !unique(cell.checks.map((check) => check.id))))
+    throw new Error("Matrix report repeats a skill, case or vendor cell. Regenerate an unambiguous report.");
+  return report;
+}
+
+// ../../packages/core/src/oma/skill-matrix-adapter.ts
+var scope = "installed injected read-reference audit; not AV runtime or task-quality certification";
+var safeNames = /^[a-z0-9][a-z0-9-]{0,127}$/;
+var remediation = "Regenerate the installed injected matrix with explicit models, then set oma.skill_compatibility.report_path in av.yaml.";
+var matrixRouteKey = (route) => `${route.actorType}\x00${route.model ?? ""}`;
+function sourceProblem(report) {
+  if (report.sourceKind !== "installed" || report.delivery !== "injected" || report.auditScope !== "read-reference" || !report.bundle)
+    return "Evidence is not an installed, injected, read-reference audit. Synthetic probes cannot authorize installed skills.";
+  return;
+}
+function sameCoverage(a, b) {
+  const sorted = (items) => JSON.stringify([...items].sort());
+  return a.hash === b.hash && a.caseId === b.caseId && sorted(a.requiredFiles) === sorted(b.requiredFiles) && sorted(a.missingFiles) === sorted(b.missingFiles) && JSON.stringify(a.excludedReferences) === JSON.stringify(b.excludedReferences);
+}
+function assessRoute(report, plan, skills, route, version) {
+  const result = (status, reason) => ({
+    ...route,
+    status,
+    reason
+  });
+  if (route.actorType !== "claude" && route.actorType !== "codex")
+    return result("unknown", "This matrix protocol measures only Claude and Codex.");
+  if (!route.model)
+    return result("unknown", "The candidate uses an unpinned native model default; it cannot match a measured model.");
+  if (!version)
+    return result("unknown", "The current native CLI version could not be verified.");
+  for (const name of skills) {
+    const current = plan.bundle?.skills.find((entry) => entry.name === name);
+    const saved = report.bundle?.skills.find((entry) => entry.name === name);
+    if (!current || !saved)
+      return result("unknown", `Skill ${name} has no complete installed audit coverage.`);
+    if (!sameCoverage(current, saved))
+      return result("unknown", `Skill ${name} content or reference coverage changed after the audit.`);
+    if (current.missingFiles.length || current.excludedReferences.length || saved.missingFiles.length || saved.excludedReferences.length)
+      return result("unknown", `Skill ${name} has missing or excluded references; complete its audit coverage first.`);
+    if (!report.cases.some((entry) => entry.id === saved.caseId && entry.skill === name))
+      return result("unknown", `Skill ${name} required case is absent from the measured selection.`);
+    const cell = report.cells.find((entry) => entry.caseId === saved.caseId && entry.vendor === route.actorType);
+    if (!cell || cell.skill !== name || cell.contentHash !== current.hash)
+      return result("unknown", `Skill ${name} lacks a matching measured vendor cell.`);
+    if (cell.cliVersion !== version)
+      return result("unknown", `Skill ${name} was measured with a different or unknown native CLI version.`);
+    if (cell.model !== route.model)
+      return result("unknown", `Skill ${name} was measured with a different or unknown reported model.`);
+    if (cell.status !== "pass" || !cell.checks.length || cell.checks.some((check) => check.status !== "pass"))
+      return result(cell.status === "fail" ? "fail" : "unknown", `Skill ${name} audit is ${cell.status}; passing read-reference evidence is required.`);
+    const entry = `${name}/SKILL.md`;
+    if (!current.requiredFiles.includes(entry))
+      return result("unknown", `Skill ${name} audit omits its installed SKILL.md.`);
+    const required = [
+      "process",
+      "output",
+      "content",
+      "integrity",
+      "reference-coverage",
+      ...current.requiredFiles.filter((file) => file !== entry).map((file) => `reference:${posix.relative(name, file)}`)
+    ];
+    if (required.some((id) => !cell.checks.some((check) => check.id === id && check.status === "pass" && (id === "content" || id.startsWith("reference:") ? check.proof === "read" : true))))
+      return result("unknown", `Skill ${name} audit lacks a mandatory successful read-reference check.`);
+  }
+  return result("pass", "All selected skills have current passing installed injected read-reference evidence.");
+}
+async function inspectSkillCompatibility(policy, workspace, selectedSkills, routes, deps = defaultSkillMatrixDeps, signal) {
+  const unknown = (reason) => ({
+    scope,
+    routes: routes.map((route) => ({ ...route, status: "unknown", reason }))
+  });
+  if (selectedSkills?.length === 0)
+    return {
+      scope,
+      routes: routes.map((route) => ({
+        ...route,
+        status: "pass",
+        reason: "No skills selected; no compatibility claim is required."
+      }))
+    };
+  try {
+    if (signal?.aborted)
+      throw new Error("Interrupted");
+    const report = parseSkillMatrix(await deps.readReport(policy.reportPath));
+    const source = sourceProblem(report);
+    if (source)
+      return unknown(source);
+    if (report.mode !== "live" || report.status !== "completed")
+      return unknown("The report is not a completed live measurement; a plan is unmeasured.");
+    const age = deps.now() - Date.parse(report.createdAt);
+    if (age < -60000 || age > policy.maxAgeHours * 3600000)
+      return unknown("The cached matrix is stale or has a future timestamp.");
+    if (report.host.platform !== deps.platform || report.host.arch !== deps.arch)
+      return unknown("The matrix host platform or architecture differs from this runtime.");
+    const skills = [...new Set(selectedSkills ?? report.bundle?.skills.map((entry) => entry.name) ?? [])];
+    if (!skills.length || skills.length > 100 || skills.some((name) => !safeNames.test(name)))
+      return unknown("Select a bounded list of valid installed skill names.");
+    const plan = parseSkillMatrix(await deps.plan(workspace, skills, signal));
+    if (sourceProblem(plan) || plan.mode !== "plan" || plan.status !== "planned")
+      return unknown("OMA did not return a supported installed injected plan.");
+    if (plan.omaVersion !== report.omaVersion)
+      return unknown("The OMA version changed after measurement; refresh the cached matrix.");
+    if (plan.host.platform !== deps.platform || plan.host.arch !== deps.arch)
+      return unknown("The current OMA plan host does not match this runtime.");
+    const versions = new Map;
+    for (const route of routes) {
+      if (versions.has(route.actorType) || route.actorType !== "claude" && route.actorType !== "codex")
+        continue;
+      try {
+        versions.set(route.actorType, await deps.cliVersion(route.actorType, signal));
+      } catch {
+        versions.set(route.actorType, null);
+      }
+    }
+    if (signal?.aborted)
+      throw new Error("Interrupted");
+    return {
+      scope,
+      routes: routes.map((route) => assessRoute(report, plan, skills, route, versions.get(route.actorType) ?? null))
+    };
+  } catch {
+    if (signal?.aborted)
+      throw new Error("Skill compatibility inspection interrupted before Actor launch.");
+    return unknown(`The cached report or local OMA plan could not be validated. ${remediation}`);
+  }
+}
+function assertCompatibleRoute(route, inspection) {
+  const result = inspection.routes.find((entry) => matrixRouteKey(entry) === matrixRouteKey(route));
+  if (result?.status !== "pass")
+    throw new Error(`Skill compatibility required for ${route.actorType}/${route.model ?? "native default"}: ${result?.reason ?? "no matching evidence"} ${remediation}`);
+}
+
 // ../../packages/core/src/orchestrator/agent-runner.ts
 init_logger();
 import { AsyncLocalStorage } from "node:async_hooks";
@@ -68798,8 +69101,8 @@ async function withMissionDeadline(mission, parent, run) {
 
 // ../../packages/core/src/chief/skills.ts
 init_dist();
-import { constants as constants5 } from "node:fs";
-import { lstat as lstat11, mkdir as mkdir13, open as open7, readdir as readdir6, realpath as realpath14, stat, writeFile as writeFile10 } from "node:fs/promises";
+import { constants as constants6 } from "node:fs";
+import { lstat as lstat11, mkdir as mkdir13, open as open8, readdir as readdir6, realpath as realpath14, stat, writeFile as writeFile10 } from "node:fs/promises";
 import { isAbsolute as isAbsolute8, join as join26, relative as relative8, sep as sep10 } from "node:path";
 var MAX_SKILL_BYTES = 256000;
 var MAX_METADATA_BYTES = 16384;
@@ -68880,7 +69183,7 @@ async function prepareMissionSkills(sourceRepositoryPath, workspacePath) {
         const parent = await realpath14(targetDirectory);
         if (parent !== destinationRoot && !inside(destinationRoot, parent))
           throw new Error("A target skill resource escapes the mission worktree. Fix its symlink before creating this order.");
-        const file = await open7(from, constants5.O_RDONLY | constants5.O_NOFOLLOW | constants5.O_NONBLOCK);
+        const file = await open8(from, constants6.O_RDONLY | constants6.O_NOFOLLOW | constants6.O_NONBLOCK);
         try {
           const current = await file.stat();
           if (!current.isFile())
@@ -68941,7 +69244,7 @@ async function skillPath(root, name) {
   return path;
 }
 async function readSkill(path, metadataOnly) {
-  const file = await open7(path, constants5.O_RDONLY | constants5.O_NOFOLLOW | constants5.O_NONBLOCK);
+  const file = await open8(path, constants6.O_RDONLY | constants6.O_NOFOLLOW | constants6.O_NONBLOCK);
   try {
     const info = await file.stat();
     if (!info.isFile())
@@ -69169,11 +69472,13 @@ class ChiefRuntime {
   store;
   signal;
   onStage;
+  skillMatrixDeps;
   runners = new Set;
-  constructor(store, signal, onStage = () => {}) {
+  constructor(store, signal, onStage = () => {}, skillMatrixDeps) {
     this.store = store;
     this.signal = signal;
     this.onStage = onStage;
+    this.skillMatrixDeps = skillMatrixDeps;
   }
   ports() {
     return {
@@ -69249,8 +69554,22 @@ class ChiefRuntime {
     };
     if (signal?.aborted)
       throw new Error("Order interrupted. Resume it with av order --resume followed by its mission ID.");
-    const route = stage === "work" ? selectWorkActor(mission, persona, context?.taskId) : undefined;
+    const compatibilityPolicy = mission.operatingPolicy?.skillCompatibility;
+    const compatibility = stage === "work" && compatibilityPolicy ? await inspectSkillCompatibility(compatibilityPolicy, workspace.path, persona.skills, workActorCandidates(mission, persona, compatibilityPolicy.mode === "require"), this.skillMatrixDeps, signal) : undefined;
+    const compatibleRoutes = compatibilityPolicy?.mode === "require" && compatibility ? new Set(compatibility.routes.filter((entry) => entry.status === "pass").map(matrixRouteKey)) : undefined;
+    if (compatibility && compatibilityPolicy)
+      mission.history.push({
+        at: new Date().toISOString(),
+        stage: "skill-compatibility",
+        message: `${compatibilityPolicy.mode}: ${compatibility.routes.map((entry) => `${entry.actorType}/${entry.model ?? "native default"} ${entry.status}: ${entry.reason}`).join("; ")} Scope: ${compatibility.scope}.`,
+        ...context?.taskId ? { taskId: context.taskId } : {}
+      });
+    const route = stage === "work" ? selectWorkActor(mission, persona, context?.taskId, compatibleRoutes) : undefined;
     persona = route?.actor ?? persona;
+    if (compatibility && compatibilityPolicy) {
+      if (compatibilityPolicy.mode === "require")
+        assertCompatibleRoute({ actorType: persona.agentType, model: persona.model }, compatibility);
+    }
     this.onStage(stage, persona);
     const attempt = {
       id: randomUUID11(),
@@ -69852,19 +70171,19 @@ init_report_delivery_contract();
 init_zod();
 init_report_delivery_contract();
 import { createHash as createHash16, randomUUID as randomUUID12 } from "node:crypto";
-import { constants as constants6 } from "node:fs";
-import { mkdir as mkdir14, open as open8, readdir as readdir7, readFile as readFile11, realpath as realpath15, rename as rename6, unlink as unlink5, writeFile as writeFile11 } from "node:fs/promises";
+import { constants as constants7 } from "node:fs";
+import { mkdir as mkdir14, open as open9, readdir as readdir7, readFile as readFile11, realpath as realpath15, rename as rename6, unlink as unlink5, writeFile as writeFile11 } from "node:fs/promises";
 import { isAbsolute as isAbsolute9, join as join28, relative as relative9, resolve as resolve16 } from "node:path";
-var hash2 = string2().regex(/^[a-f0-9]{64}$/);
+var hash3 = string2().regex(/^[a-f0-9]{64}$/);
 var outboxRecordSchema = strictObject({
   version: literal(1),
-  id: hash2,
+  id: hash3,
   missionId: string2().regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/),
   missionStatus: _enum(["completed", "failed"]),
   destinationId: string2().regex(/^[a-zA-Z0-9][a-zA-Z0-9_-]{0,63}$/),
   channel: string2().regex(/^[a-z][a-z0-9-]{0,63}$/),
-  reportHash: hash2,
-  destinationHash: hash2.optional(),
+  reportHash: hash3,
+  destinationHash: hash3.optional(),
   goal: string2().max(32000),
   markdown: string2().max(256000),
   reportPath: string2().max(4096),
@@ -69899,7 +70218,7 @@ class ReportOutbox {
     this.directory = join28(stateDir, "report-outbox");
   }
   path(id) {
-    if (!hash2.safeParse(id).success)
+    if (!hash3.safeParse(id).success)
       throw new Error("Invalid report receipt ID. Use av reports to find a receipt.");
     return join28(this.directory, `${id}.json`);
   }
@@ -69962,7 +70281,7 @@ async function verifiedAttachment(attachment, artifactRoot, readBytes) {
       throw failure;
     if (resolve16(attachment.path) !== attachment.path)
       throw failure;
-    const file = await open8(attachment.path, constants6.O_RDONLY | constants6.O_NOFOLLOW);
+    const file = await open9(attachment.path, constants7.O_RDONLY | constants7.O_NOFOLLOW);
     try {
       const stat = await file.stat();
       if (!stat.isFile() || stat.size !== attachment.sizeBytes)
@@ -70497,8 +70816,8 @@ Return one valid JSON object under the original charter and pinned evidence.` :
 
 // ../../packages/core/src/chief/metric-source-adapters.ts
 init_metric_source_policy();
-import { constants as constants7 } from "node:fs";
-import { lstat as lstat12, open as open9, realpath as realpath16 } from "node:fs/promises";
+import { constants as constants8 } from "node:fs";
+import { lstat as lstat12, open as open10, realpath as realpath16 } from "node:fs/promises";
 import { isAbsolute as isAbsolute10, relative as relative10, resolve as resolve17, sep as sep11 } from "node:path";
 var MAX_METRIC_RESPONSE_BYTES = 2000000;
 function metricSourceEnvironment(request, name) {
@@ -70596,7 +70915,7 @@ var jsonFileMetricAdapter = {
       if ((await lstat12(current)).isSymbolicLink())
         throw new MetricSourceError("Metric file and parent directories must not be symlinks. Choose a regular JSON file inside the source repository.");
     }
-    const file = await open9(path, constants7.O_RDONLY | constants7.O_NOFOLLOW);
+    const file = await open10(path, constants8.O_RDONLY | constants8.O_NOFOLLOW);
     try {
       const stat = await file.stat();
       if (!stat.isFile() || stat.size > MAX_METRIC_RESPONSE_BYTES || await realpath16(path) !== path)
@@ -70997,8 +71316,8 @@ function createMissionMetricPorts(repository, mission, dependencies = {}) {
 
 // src/chief-tool-config.ts
 import { randomUUID as randomUUID14 } from "node:crypto";
-import { constants as constants8 } from "node:fs";
-import { link as link2, lstat as lstat13, mkdir as mkdir16, open as open10, realpath as realpath17, unlink as unlink6 } from "node:fs/promises";
+import { constants as constants9 } from "node:fs";
+import { link as link2, lstat as lstat13, mkdir as mkdir16, open as open11, realpath as realpath17, unlink as unlink6 } from "node:fs/promises";
 import { join as join32 } from "node:path";
 init_dist2();
 init_client_toml();
@@ -71032,7 +71351,7 @@ async function assertLocalPath(root, local) {
   return true;
 }
 async function readPrivateFile(path) {
-  const file = await open10(path, constants8.O_RDONLY | constants8.O_NOFOLLOW);
+  const file = await open11(path, constants9.O_RDONLY | constants9.O_NOFOLLOW);
   try {
     const stats = await file.stat();
     if (!stats.isFile() || stats.size > maximumBytes)
@@ -71095,7 +71414,7 @@ async function privateExclude(original, target, paths) {
   const patterns = paths.flatMap((local) => [`/${local}`, `/${local}.av-mcp-*.tmp`]).filter((pattern) => !lines.has(pattern));
   if (!patterns.length)
     return;
-  const file = await open10(path, constants8.O_WRONLY | constants8.O_APPEND | constants8.O_CREAT | constants8.O_NOFOLLOW, 384);
+  const file = await open11(path, constants9.O_WRONLY | constants9.O_APPEND | constants9.O_CREAT | constants9.O_NOFOLLOW, 384);
   try {
     await file.writeFile(`${content && !content.endsWith(`
 `) ? `
@@ -71140,7 +71459,7 @@ async function prepareToolConfig(originalRepository, targetWorkspace) {
       continue;
     const path = join32(target, config.path);
     const temporary = `${path}.av-mcp-${randomUUID14()}.tmp`;
-    const file = await open10(temporary, "wx", 384);
+    const file = await open11(temporary, "wx", 384);
     try {
       await file.writeFile(config.content);
     } finally {
@@ -71169,7 +71488,7 @@ async function prepareChiefToolConfig(originalRepository, targetWorkspace) {
 
 // src/tool-discovery.ts
 init_client_toml();
-import { constants as constants9 } from "node:fs";
+import { constants as constants10 } from "node:fs";
 import { access, lstat as lstat14, readFile as readFile12, realpath as realpath18 } from "node:fs/promises";
 import { homedir as homedir6 } from "node:os";
 import { delimiter as delimiter2, isAbsolute as isAbsolute11, join as join33, resolve as resolve18 } from "node:path";
@@ -71191,7 +71510,7 @@ async function executable(name, env) {
   for (const directory of (env.PATH ?? "").split(delimiter2).filter(isAbsolute11)) {
     try {
       const path = join33(directory, name);
-      await access(path, constants9.X_OK);
+      await access(path, constants10.X_OK);
       if ((await lstat14(await realpath18(path))).isFile())
         return true;
     } catch {}
@@ -71446,7 +71765,7 @@ async function decideContinuousGoal(operation, decisionId, root, dependencies =
 }
 
 // src/chief-continuous.ts
-var execute = promisify2(execFile4);
+var execute = promisify2(execFile5);
 var orderKeys = [
   "workspace",
   "verify",
@@ -73135,7 +73454,7 @@ function selectTaskReviewer(mission, task, state) {
 }
 
 // ../../packages/core/src/chief/coordinator.ts
-var bounded2 = (value) => value.slice(-32000);
+var bounded3 = (value) => value.slice(-32000);
 async function coordinate(mission, ports) {
   Object.assign(mission, validateMission(mission));
   const operatorGoal = mission.goal;
@@ -73199,7 +73518,7 @@ async function coordinate(mission, ports) {
         if (task.effectScope === "external" && state.effectState === "unknown")
           throw new MissionPause(`External effect ${task.id} has no established destination outcome and will not be repeated.`, "unknown-effect");
         if (task.effectScope !== "external" || state.effectState !== "completed") {
-          state.output = bounded2(await run(persona(task.personaId), workPrompt(mission, task, state, persona(task.personaId)), "work", task.id));
+          state.output = bounded3(await run(persona(task.personaId), workPrompt(mission, task, state, persona(task.personaId)), "work", task.id));
           if (task.effectScope === "external")
             state.effectState = "completed";
         }
@@ -73373,7 +73692,7 @@ async function coordinate(mission, ports) {
       mission.fingerprint = await ports.fingerprint(mission);
       mission.verification = {
         ok: result.ok,
-        output: result.output ? bounded2(result.output) : undefined,
+        output: result.output ? bounded3(result.output) : undefined,
         fingerprint: mission.fingerprint
       };
       if (mission.verificationMode === "chief" && !mission.goalVerification?.ok) {
@@ -73472,7 +73791,7 @@ async function coordinate(mission, ports) {
       return mission;
     }
     mission.status = "failed";
-    mission.error = bounded2(error instanceof Error ? error.message : String(error));
+    mission.error = bounded3(error instanceof Error ? error.message : String(error));
     if (error instanceof ReadOnlyViolation || error instanceof ContractViolation || error instanceof CheckpointError)
       executionState(mission).failureKind = "integrity";
     if (error instanceof ReadOnlyViolation)
@@ -73489,7 +73808,7 @@ async function coordinate(mission, ports) {
           if (reportError instanceof ReadOnlyViolation) {
             executionState(mission).failureKind = "integrity";
             invalidate();
-            mission.error = bounded2(`${mission.error}
+            mission.error = bounded3(`${mission.error}
 ${reportError.message}`);
             mission.report = fallbackReport(mission);
           }
@@ -74623,6 +74942,37 @@ function checkOma(project, deps) {
   return results;
 }
 
+// src/doctor-skill-matrix-checks.ts
+import { resolve as resolve26 } from "node:path";
+async function checkSkillMatrix(project, global2, deps) {
+  const config = project?.oma?.skill_compatibility;
+  if (!config)
+    return [];
+  const projectActor = project?.actor ?? project?.agent;
+  const globalActor = global2?.actor ?? global2?.agent;
+  const actorType = projectActor?.type ?? globalActor?.type ?? "claude";
+  const model = projectActor?.model ?? (globalActor?.type === actorType ? globalActor.model : undefined);
+  const inspection = await inspectSkillCompatibility({
+    reportPath: resolve26(deps.cwd, config.report_path),
+    maxAgeHours: config.max_age_hours,
+    mode: config.mode
+  }, resolve26(deps.cwd, project?.workspace?.root ?? "."), undefined, [{ actorType, model }], deps.skillMatrix);
+  const route = inspection.routes[0];
+  const status = route?.status ?? "unknown";
+  return [
+    {
+      id: "oma.skill-compatibility",
+      name: "OMA skill read-reference compatibility",
+      status,
+      message: `${config.mode}: ${actorType}/${model ?? "native default"}: ${route?.reason ?? "Evidence unavailable."} Scope: ${inspection.scope}. Work dispatch rechecks its own selected skills and candidates.`,
+      ...status !== "pass" ? {
+        fix: "Generate a completed installed injected matrix with explicit models and set oma.skill_compatibility.report_path in av.yaml. av doctor never runs a live matrix."
+      } : {},
+      critical: config.mode === "require"
+    }
+  ];
+}
+
 // src/doctor-config-checks.ts
 function checkTunnel(project, deps) {
   const provider = project?.tunnel?.provider ?? "ngrok";
@@ -74877,10 +75227,11 @@ async function runDoctorChecks(deps, options = {}) {
   results.push(checkTunnel(project, deps));
   results.push(checkWebhookSecret(project));
   results.push(...checkOma(project, deps));
+  results.push(...await checkSkillMatrix(project, global2, deps));
   return results;
 }
 function computeExitCode(results) {
-  return results.some((r) => r.critical && r.status === "fail") ? 1 : 0;
+  return results.some((r) => r.critical && (r.status === "fail" || r.status === "unknown")) ? 1 : 0;
 }
 function summarize(results) {
   return { passed: results.filter((r) => r.status === "pass").length, total: results.length };
@@ -74955,7 +75306,7 @@ async function registerLinearWebhook(root, tunnelUrl) {
 init_yaml_loader();
 import { existsSync as existsSync5, readFileSync as readFileSync10, writeFileSync as writeFileSync2 } from "node:fs";
 import { createServer as createServer3 } from "node:net";
-import { resolve as resolve26 } from "node:path";
+import { resolve as resolve27 } from "node:path";
 import { setTimeout as delay } from "node:timers/promises";
 
 // src/webhook-proxy.ts
@@ -75070,12 +75421,12 @@ function resolveServerPort(root, runningPort) {
   return String(port);
 }
 function resolveRuntimePaths(root, cliDir) {
-  const dashboardCwd = resolve26(root, "apps/dashboard");
-  if (!existsSync5(resolve26(dashboardCwd, "package.json"))) {
+  const dashboardCwd = resolve27(root, "apps/dashboard");
+  if (!existsSync5(resolve27(dashboardCwd, "package.json"))) {
     throw new Error(`Dashboard source is missing at ${dashboardCwd}. Clone https://github.com/first-fluke/agent-valley, run bun install, then run bun av setup and bun av dev from that checkout. The standalone CLI does not include the dashboard.`);
   }
-  const bundled = resolve26(cliDir, "supervisor.js");
-  const supervisorScript = existsSync5(bundled) ? bundled : resolve26(cliDir, "supervisor.ts");
+  const bundled = resolve27(cliDir, "supervisor.js");
+  const supervisorScript = existsSync5(bundled) ? bundled : resolve27(cliDir, "supervisor.ts");
   if (!existsSync5(supervisorScript)) {
     throw new Error(`Supervisor is missing at ${supervisorScript}. Run bun av up from an intact Agent Valley checkout.`);
   }
@@ -75354,8 +75705,8 @@ function spawnTunnel(config, input) {
 
 // src/index.ts
 var ROOT = process.cwd();
-var PID_FILE = resolve30(ROOT, ".av.pid");
-var LOG_FILE = resolve30(ROOT, ".av.log");
+var PID_FILE = resolve31(ROOT, ".av.pid");
+var LOG_FILE = resolve31(ROOT, ".av.log");
 function ensureConfig() {
   if (!existsSync10(resolveProjectConfigPath(ROOT))) {
     console.log(import_picocolors15.default.red("No av.yaml found. Run `av setup` first."));