@event4u/agent-config 8.13.0 → 9.0.0

package/src/scripts/run_skill_evals.ts

@@ -105,10 +105,15 @@ export function _spawn_subagent(
  *
  * Deterministic on purpose: this only *counts*. The substantive judgement —
  * is each match a real finding, and what should `n` be per host — is the
- * calibration layer (Phase 1 gold set + per-host floor), which is gated on the
- * P0 cross-model distributions and therefore NOT wired here yet. So
- * `finding_floor` is available as a mechanism and exercised by fixtures, but is
- * not an enforcing CI gate until calibrated.
+ * calibration layer. CALIBRATED 2026-07-12: the cross-model count-distribution
+ * pass (`bench_parity_count.ts`, design in
+ * `docs/design/cross-model-parity-eval.md`) recorded per-host finding-count
+ * distributions over the orchestration corpus for 2 vendors and derived
+ * per-task floors from the cross-host lower envelope
+ * (`internal/bench/reports/parity-count.json`). `finding_floor` is therefore an
+ * ENFORCING gate: a fixture's `n` is justified against the cross-vendor norm,
+ * not one vendor's output shape. New floors follow the same envelope rule
+ * (max(1, min over hosts of median count); negative controls excluded).
  */
 export function _count_findings(output: string, pattern?: string): number {
     if (pattern !== undefined && pattern !== '') {
@@ -130,6 +135,31 @@ export function _count_findings(output: string, pattern?: string): number {
     return count;
 }
 
+/**
+ * Load the recorded tool trace from `<run_dir>/tool-trace.json` — an array of
+ * tool-call names (strings) or `{tool: string}` objects. Returns null when the
+ * file is absent (→ tool-choice / trajectory assertions report manual-pending).
+ */
+export function _load_tool_trace(run_dir: string): string[] | null {
+    const p = path.join(run_dir, 'tool-trace.json');
+    if (!_exists(p)) return null;
+    const raw = JSON.parse(fs.readFileSync(p, 'utf-8')) as Array<string | { tool?: string }>;
+    if (!Array.isArray(raw)) return null;
+    return raw.map((e) => (typeof e === 'string' ? e : (e.tool ?? ''))).filter((s) => s !== '');
+}
+
+/** Count meaningful steps: tool calls net of retries (a call whose name equals
+ * the immediately-preceding call name is a retry, not a new step). */
+export function _count_meaningful_steps(trace: string[]): number {
+    let steps = 0;
+    let prev: string | null = null;
+    for (const t of trace) {
+        if (t !== prev) steps += 1;
+        prev = t;
+    }
+    return steps;
+}
+
 export function _grade_assertions(
     output: string,
     run_dir: string,
@@ -141,6 +171,10 @@ export function _grade_assertions(
         if (kind === 'contains') {
             const ok = output.includes(a['value'] as string);
             results.push({ kind, value: a['value'] as JsonValue, pass: ok });
+        } else if (kind === 'not_contains') {
+            // U2 golden-adversarial negative: benign look-alikes must NOT be flagged.
+            const ok = !output.includes(a['value'] as string);
+            results.push({ kind, value: a['value'] as JsonValue, pass: ok });
         } else if (kind === 'file_exists') {
             const apath = a['path'] as string;
             const ok = _exists(path.join(run_dir, apath)) || _exists(apath);
@@ -157,6 +191,38 @@ export function _grade_assertions(
             const pattern = a['pattern'] as string | undefined;
             const count = _count_findings(output, pattern);
             results.push({ kind, n, count, pass: count >= n });
+        } else if (kind === 'tool-choice') {
+            // Evaluated against the recorded tool trace (<run_dir>/tool-trace.json).
+            // No trace (e.g. scaffold-only / CI without a live run) → manual-pending,
+            // NEVER a silent pass.
+            const mustUse = (a['must_use'] as string[] | undefined) ?? [];
+            const mustNot = (a['must_not_use'] as string[] | undefined) ?? [];
+            const trace = _load_tool_trace(run_dir);
+            if (trace === null) {
+                results.push({
+                    kind, must_use: mustUse, must_not_use: mustNot, pass: null,
+                    note: 'manual-pending: no tool-trace.json in run dir — record a trace or grade manually',
+                });
+            } else {
+                const used = new Set(trace);
+                const missing = mustUse.filter((t) => !used.has(t));
+                const forbidden = mustNot.filter((t) => used.has(t));
+                results.push({
+                    kind, must_use: mustUse, must_not_use: mustNot,
+                    missing, forbidden, pass: missing.length === 0 && forbidden.length === 0,
+                });
+            }
+        } else if (kind === 'trajectory_budget') {
+            // Meaningful step = one tool call net of retries (a retry is a call whose
+            // tool name repeats the immediately-preceding call). No trace → manual-pending.
+            const budget = a['n'] as number;
+            const trace = _load_tool_trace(run_dir);
+            if (trace === null) {
+                results.push({ kind, n: budget, pass: null, note: 'manual-pending: no tool-trace.json in run dir' });
+            } else {
+                const steps = _count_meaningful_steps(trace);
+                results.push({ kind, n: budget, steps, pass: steps <= budget });
+            }
         } else {
             results.push({ kind: kind ?? null, pass: false, note: `unknown assertion kind ${_pyRepr(kind)}` });
         }

package/src/scripts/schemas/command.schema.json

@@ -35,6 +35,13 @@
       "default": true,
       "description": "Commands are always user-invoked; model-invocation is disabled."
     },
+    "argument-hint": {
+      "type": "string",
+      "minLength": 1,
+      "maxLength": 120,
+      "description": "Official-spec argument hint shown next to the slash command in hosts that render one (Claude Code). Bracket notation: `<required>` / `[optional]`, e.g. '<ticket-key | url> [notes]'. Set on every command whose body documents an invocation argument; omit on zero-argument commands. Projection: commands symlink into .claude/skills/<slug>/SKILL.md, so the field reaches Claude Code verbatim; other hosts ignore it (see docs/parity/command-frontmatter.md).",
+      "$comment": "road-to-ecosystem-harvest-skill-quality-gates Phase 4, Source C (official CLI command-authoring standard)."
+    },
     "skills": {
       "type": "array",
       "items": {

package/src/scripts/schemas/evals.schema.json

@@ -3,10 +3,13 @@
   "$id": "https://github.com/event4u-app/agent-config/scripts/schemas/evals.schema.json",
   "x-schemaVersion": "1.0.0",
   "title": "Skill behavioural evals (evals.json)",
-  "$comment": "Behavioural-eval spec consumed by run_skill_evals.ts (scaffold/aggregate/report) and counted by skill_eval_coverage.ts. Distinct from triggers.json (activation/routing axis). Roadmap: road-to-skill-eval-coverage Phase 1. Assertion kinds mirror _grade_assertions() in run_skill_evals.ts exactly — add a kind there before adding it here.",
+  "$comment": "Behavioural-eval spec consumed by run_skill_evals.ts (scaffold/aggregate/report) and counted by skill_eval_coverage.ts. Distinct from triggers.json (activation/routing axis). Roadmap: road-to-skill-eval-coverage Phase 1. Assertion kinds mirror _grade_assertions() in run_skill_evals.ts exactly \u2014 add a kind there before adding it here.",
   "type": "object",
   "additionalProperties": false,
-  "required": ["skill", "scenarios"],
+  "required": [
+    "skill",
+    "scenarios"
+  ],
   "properties": {
     "skill": {
       "type": "string",
@@ -20,7 +23,7 @@
     "skill_body_sha": {
       "type": "string",
       "pattern": "^[0-9a-f]{64}$",
-      "description": "Optional SHA-256 of the skill's SKILL.md body at the time these evals were authored/last verified. When present, lint_behavioural_eval_freshness flags the eval stale if the current SKILL.md sha differs — the body changed, so the eval may no longer exercise it. Absent = unpinned (out of scope for the staleness gate), mirroring lint_eval_freshness's upstream:null handling."
+      "description": "Optional SHA-256 of the skill's SKILL.md body at the time these evals were authored/last verified. When present, lint_behavioural_eval_freshness flags the eval stale if the current SKILL.md sha differs \u2014 the body changed, so the eval may no longer exercise it. Absent = unpinned (out of scope for the staleness gate), mirroring lint_eval_freshness's upstream:null handling."
     },
     "scenarios": {
       "type": "array",
@@ -29,7 +32,11 @@
       "items": {
         "type": "object",
         "additionalProperties": false,
-        "required": ["id", "prompt", "assertions"],
+        "required": [
+          "id",
+          "prompt",
+          "assertions"
+        ],
         "properties": {
           "id": {
             "type": "string",
@@ -41,6 +48,20 @@
             "minLength": 1,
             "description": "The input fixture handed to the skill under test."
           },
+          "environment": {
+            "type": "string",
+            "minLength": 1,
+            "description": "Optional precondition note (v2, additive) — the environment the scenario assumes (e.g. 'a git repo with an open PR', 'quality.local_auto_run: true'). Advisory context for the runner/operator; not graded."
+          },
+          "requires_human": {
+            "type": "boolean",
+            "description": "Optional (v2, additive). When true, the scenario cannot be auto-graded in CI — the runner skips it and reports `manual-pending` (NEVER a silent pass). Pair with human_instructions."
+          },
+          "human_instructions": {
+            "type": "string",
+            "minLength": 1,
+            "description": "Optional (v2, additive). Steps for a human to grade a requires_human scenario."
+          },
           "assertions": {
             "type": "array",
             "minItems": 1,
@@ -50,9 +71,14 @@
                 {
                   "type": "object",
                   "additionalProperties": false,
-                  "required": ["kind", "value"],
+                  "required": [
+                    "kind",
+                    "value"
+                  ],
                   "properties": {
-                    "kind": { "const": "contains" },
+                    "kind": {
+                      "const": "contains"
+                    },
                     "value": {
                       "type": "string",
                       "minLength": 1,
@@ -63,9 +89,14 @@
                 {
                   "type": "object",
                   "additionalProperties": false,
-                  "required": ["kind", "path"],
+                  "required": [
+                    "kind",
+                    "path"
+                  ],
                   "properties": {
-                    "kind": { "const": "file_exists" },
+                    "kind": {
+                      "const": "file_exists"
+                    },
                     "path": {
                       "type": "string",
                       "minLength": 1,
@@ -76,13 +107,18 @@
                 {
                   "type": "object",
                   "additionalProperties": false,
-                  "required": ["kind", "n"],
+                  "required": [
+                    "kind",
+                    "n"
+                  ],
                   "properties": {
-                    "kind": { "const": "finding_floor" },
+                    "kind": {
+                      "const": "finding_floor"
+                    },
                     "n": {
                       "type": "integer",
                       "minimum": 0,
-                      "description": "Minimum number of findings the output must carry (counted deterministically). 0 is a trivially-passing floor (the grader passes when count >= n) — used where the case only guards against over-reporting."
+                      "description": "Minimum number of findings the output must carry (counted deterministically). 0 is a trivially-passing floor (the grader passes when count >= n) \u2014 used where the case only guards against over-reporting."
                     },
                     "pattern": {
                       "type": "string",
@@ -93,13 +129,68 @@
                 {
                   "type": "object",
                   "additionalProperties": false,
-                  "required": ["kind", "criterion"],
+                  "required": [
+                    "kind",
+                    "criterion"
+                  ],
                   "properties": {
-                    "kind": { "const": "rubric" },
+                    "kind": {
+                      "const": "rubric"
+                    },
                     "criterion": {
                       "type": "string",
                       "minLength": 1,
-                      "description": "Natural-language pass criterion graded by a sub-agent. NON-deterministic — the grader returns pass:null until a pinned judge fills it. Use only where no deterministic check exists; record the judge as a known limit."
+                      "description": "Natural-language pass criterion graded by a sub-agent. NON-deterministic \u2014 the grader returns pass:null until a pinned judge fills it. Use only where no deterministic check exists; record the judge as a known limit."
+                    }
+                  }
+                },
+                {
+                  "type": "object",
+                  "additionalProperties": false,
+                  "required": [
+                    "kind",
+                    "value"
+                  ],
+                  "properties": {
+                    "kind": {
+                      "const": "not_contains"
+                    },
+                    "value": {
+                      "type": "string",
+                      "minLength": 1,
+                      "description": "Substring the output must contain (deterministic)."
+                    }
+                  }
+                },
+                {
+                  "type": "object",
+                  "additionalProperties": false,
+                  "required": ["kind"],
+                  "properties": {
+                    "kind": { "const": "tool-choice" },
+                    "must_use": {
+                      "type": "array",
+                      "items": { "type": "string", "minLength": 1 },
+                      "description": "Tool names the run MUST have called (checked against <run_dir>/tool-trace.json). v2, additive."
+                    },
+                    "must_not_use": {
+                      "type": "array",
+                      "items": { "type": "string", "minLength": 1 },
+                      "description": "Tool names the run MUST NOT have called. v2, additive."
+                    }
+                  },
+                  "$comment": "Evaluated against the recorded tool trace. No trace present → pass:null manual-pending, never a silent pass."
+                },
+                {
+                  "type": "object",
+                  "additionalProperties": false,
+                  "required": ["kind", "n"],
+                  "properties": {
+                    "kind": { "const": "trajectory_budget" },
+                    "n": {
+                      "type": "integer",
+                      "minimum": 1,
+                      "description": "Ceiling on meaningful steps = tool calls net of retries (a call repeating the immediately-preceding call name is a retry, not a step). Counted from <run_dir>/tool-trace.json; no trace → manual-pending. v2, additive."
                     }
                   }
                 }

package/src/scripts/schemas/prelaunch-report.schema.json

@@ -0,0 +1,107 @@
+{
+  "$schema": "http://json-schema.org/draft-07/schema#",
+  "$id": "https://github.com/event4u-app/agent-config/scripts/schemas/prelaunch-report.schema.json",
+  "x-schemaVersion": "1.0.0",
+  "title": "Pre-launch diagnostic report",
+  "$comment": "road-to-ecosystem-harvest-prelaunch-diagnostics Phase 1 (Source L). Contract: docs/contracts/prelaunch-diagnostics.md. Area vocabulary: src/config/prelaunch-areas.yml. Epistemics: pass requires evidence; absence of findings is unknown, never an automatic pass; not-applicable requires a reason. NO numeric score field — the 0-100 score is council-locked (revisit note in the roadmap); adding one here is a contract violation.",
+  "type": "object",
+  "additionalProperties": false,
+  "required": ["schema_version", "project", "run_at", "areas", "findings"],
+  "properties": {
+    "schema_version": {
+      "type": "string",
+      "enum": ["prelaunch-report-v1"]
+    },
+    "project": {
+      "type": "string",
+      "minLength": 1,
+      "description": "Consumer project identifier (repo slug or name)."
+    },
+    "run_at": {
+      "type": "string",
+      "minLength": 1,
+      "description": "ISO-8601 timestamp of the diagnostic run."
+    },
+    "areas": {
+      "type": "object",
+      "additionalProperties": false,
+      "description": "Per-area epistemic state. Keys come from src/config/prelaunch-areas.yml. An area missing here is UNKNOWN by definition.",
+      "patternProperties": {
+        "^[a-z][a-z0-9-]*$": {
+          "type": "object",
+          "additionalProperties": false,
+          "required": ["state"],
+          "properties": {
+            "state": {
+              "type": "string",
+              "enum": ["pass", "finding", "unknown", "not-applicable"],
+              "description": "pass = evidence-cited clean; finding = at least one open finding (IDs in findings[]); unknown = not diagnosed — NEVER an automatic pass; not-applicable = does not exist on this launch surface (reason required)."
+            },
+            "evidence": {
+              "type": "string",
+              "minLength": 1,
+              "description": "Citation proving the state — file:line, command output, run URL. REQUIRED when state is pass (enforced by the validator; a pass without evidence is assertion, not diagnosis)."
+            },
+            "reason": {
+              "type": "string",
+              "minLength": 1,
+              "description": "REQUIRED when state is not-applicable — why the area does not exist on this surface."
+            }
+          }
+        }
+      }
+    },
+    "findings": {
+      "type": "array",
+      "description": "Every finding ever assigned in this project, open or resolved — IDs are immutable and never re-assigned, so resolved findings stay (status flips, the entry never disappears).",
+      "items": {
+        "type": "object",
+        "additionalProperties": false,
+        "required": ["id", "area", "severity", "title", "status"],
+        "properties": {
+          "id": {
+            "type": "string",
+            "pattern": "^AC-[A-Z][A-Z0-9]{1,7}-[0-9]{3}$",
+            "description": "Immutable finding ID: AC-<AREA-CODE>-NNN. The AREA code comes from prelaunch-areas.yml; NNN is zero-padded, monotonically assigned, NEVER re-used — a retitled or re-scoped finding keeps its ID; a genuinely new problem gets the next number."
+          },
+          "area": {
+            "type": "string",
+            "pattern": "^[a-z][a-z0-9-]*$",
+            "description": "Area key (prelaunch-areas.yml) the finding belongs to; must agree with the ID's area code (validator-enforced)."
+          },
+          "severity": {
+            "type": "string",
+            "enum": ["P0", "P1", "P2", "P3"],
+            "description": "P0 = launch-blocking; P1 = fix-before-general-rollout; P2 = fix-soon; P3 = nice-to-have. Any OPEN P0 refuses a ready verdict regardless of every other area."
+          },
+          "title": {
+            "type": "string",
+            "minLength": 1,
+            "maxLength": 200,
+            "description": "Human title. Mutable — the ID, not the title, is the diff key."
+          },
+          "evidence": {
+            "type": "string",
+            "minLength": 1,
+            "description": "Citation locating the finding (file:line, endpoint, config key)."
+          },
+          "status": {
+            "type": "string",
+            "enum": ["open", "fixed", "accepted-risk", "deferred-with-reason", "suppressed-with-evidence", "not-applicable"],
+            "description": "Fix-loop status vocabulary (Phase 3). Everything except open/fixed requires `reason`; suppressed-with-evidence additionally requires a matching entry in the project suppression file."
+          },
+          "reason": {
+            "type": "string",
+            "minLength": 1,
+            "description": "REQUIRED for accepted-risk / deferred-with-reason / suppressed-with-evidence / not-applicable."
+          }
+        }
+      }
+    },
+    "questions": {
+      "type": "array",
+      "items": {"type": "string", "minLength": 1},
+      "description": "Questions that would change the diagnosis — open information gaps the next run should answer; the honest sibling of the unknowns."
+    }
+  }
+}

package/src/scripts/schemas/skill.schema.json

@@ -23,6 +23,11 @@
       "maxLength": 220,
       "description": "Trigger phrase; ≤ 200 chars recommended, 220 is the ceiling (lean-initial-context: descriptions load eagerly via progressive disclosure). Over-cap is a soft warning, not a hard fail — a warning window so authors adapt."
     },
+    "compatibility": {
+      "type": "string",
+      "maxLength": 500,
+      "description": "Agent-Skills spec field (optional): machine-readable declaration of environment requirements — system packages, network access, product/host constraints. Mirrors the public spec so media/doc skills can state requirements outside prose."
+    },
     "source": {
       "type": "string",
       "enum": ["package", "project"],
@@ -87,6 +92,12 @@
       "enum": ["large"],
       "description": "Optional orthogonal modifier (ADR-035): the skill needs a large-context model regardless of reasoning tier (e.g. summarising a 500-page log). Sparse — most skills omit it. Metadata only; does not change the native Claude `model:` (the tier owns the model choice)."
     },
+    "effort": {
+      "type": "string",
+      "enum": ["low", "medium", "high", "max"],
+      "description": "Optional pinned reasoning-effort level for hosts with an effort knob (Claude Code `--effort` / agent frontmatter). Passthrough: skills project verbatim, so the key reaches Claude Code as-is and is inert on hosts without the knob. The bench harness pins it per run (bench_ab_task_runner `--effort`) so measurements are reproducible. Orthogonal to `model_tier` (capability band) — effort tunes how hard the model thinks, not which model runs. Omit unless the skill measurably needs a non-default effort.",
+      "$comment": "road-to-ecosystem-harvest-skill-quality-gates Phase 4, Source S (pinned effort frontmatter)."
+    },
     "council_depth": {
       "type": "string",
       "enum": ["deep"],
@@ -130,7 +141,13 @@
         },
         "allowed_tools": {
           "type": "array",
-          "items": { "type": "string" }
+          "items": { "type": "string" },
+          "description": "Allow-list of tool grants. Prefer the scoped-grant syntax over bare tool names where the host supports it — e.g. Bash(npm test:*) instead of Bash — per tool-safety Least Agency."
+        },
+        "disallowed_tools": {
+          "type": "array",
+          "items": { "type": "string" },
+          "description": "U3 (ecosystem harvest): optional deny-list layered UNDER allowed_tools — defense-in-depth; a tool matching here is refused even if a broad allow pattern would admit it. Supports the scoped-grant syntax (e.g. Bash(git push:*))."
         },
         "command": {
           "type": "array",

package/src/scripts/schemas/subagent.schema.json

@@ -37,6 +37,12 @@
       "enum": ["lite", "medium", "high", "inherit"],
       "description": "Vendor-neutral capability band (ADR-034/035). high/medium/lite project to a native Claude `model:` (high→opus, medium→sonnet, lite→haiku) via model_tier.ts; `inherit` is a documented passthrough sentinel (→ CC `model: inherit`), not a new mapping."
     },
+    "effort": {
+      "type": "string",
+      "enum": ["low", "medium", "high", "max"],
+      "description": "Optional pinned reasoning-effort level. Projects into the generated .claude/agents/<name>.md frontmatter (`effort:`) on hosts with an effort knob; ignored elsewhere. Orthogonal to `model_tier`. Omit for host-default effort.",
+      "$comment": "road-to-ecosystem-harvest-skill-quality-gates Phase 4, Source S."
+    },
     "tools": {
       "type": "array",
       "minItems": 1,

package/src/scripts/skill_linter.ts

@@ -196,7 +196,7 @@ const VALID_EXECUTION_FIELDS = new Set([
     'timeout_seconds',
     'safety_mode',
     'allowed_tools',
-    'command',
+    'command', 'disallowed_tools',
 ]);
 
 // --- Wing-3 GTM cognition-boundary patterns ---
@@ -1404,6 +1404,29 @@ export function lint_skill(p: string, text: string): LintResult {
         issues.push(new Issue('warning', 'missing_description', 'Frontmatter description is missing or unreadable'));
     }
 
+    // --- Agent-Skills spec alignment (U2, ecosystem harvest 2026-07-13) ---
+    // Public-spec name rules for spec-portable skills: frontmatter `name`
+    // must match the parent directory; no consecutive hyphens.
+    {
+        const fmNameMatch = text.match(/^name:\s*["']?([A-Za-z0-9-]+)["']?\s*$/m);
+        const fmName = fmNameMatch ? fmNameMatch[1] : null;
+        if (basename(p) === 'SKILL.md' && fmName && fmName !== parentName(p)) {
+            issues.push(new Issue(
+                'error',
+                'spec_name_dir_mismatch',
+                `Frontmatter name \`${fmName}\` must match the parent directory \`${parentName(p)}\` (Agent-Skills spec)`,
+            ));
+        }
+        const nameForHyphens = fmName ?? (basename(p) === 'SKILL.md' ? parentName(p) : stem(p));
+        if (nameForHyphens && nameForHyphens.includes('--')) {
+            issues.push(new Issue(
+                'error',
+                'spec_name_consecutive_hyphens',
+                `Skill name \`${nameForHyphens}\` contains consecutive hyphens (Agent-Skills spec forbids them)`,
+            ));
+        }
+    }
+
     // --- Bare-noun name check ---
     const skillName = basename(p) === 'SKILL.md' ? parentName(p) : stem(p);
     if (skillName && !skillName.includes('-') && skillName.length >= 3) {
@@ -1670,7 +1693,7 @@ export function validate_evals_json(skillPath: string): Issue[] {
         );
         return issues;
     }
-    const validKinds = ['contains', 'file_exists', 'rubric', 'finding_floor'];
+    const validKinds = ['contains', 'not_contains', 'file_exists', 'rubric', 'finding_floor', 'tool-choice', 'trajectory_budget'];
     const validKindsSet = new Set(validKinds);
     scenarios.forEach((scenario, idx) => {
         const loc = `scenarios[${idx}]`;
@@ -1726,8 +1749,25 @@ export function validate_evals_json(skillPath: string): Issue[] {
                         new Issue('warning', 'evals_json_assertion_field_type', `${aLoc} (kind=finding_floor) 'pattern' must be a string`),
                     );
                 }
+            } else if (kind === 'tool-choice') {
+                // tool-choice (eval-schema v2): `must_use` / `must_not_use` are both
+                // OPTIONAL string arrays — validate type only when present.
+                for (const f of ['must_use', 'must_not_use']) {
+                    if (f in a && !(Array.isArray(a[f]) && (a[f] as unknown[]).every((x) => typeof x === 'string'))) {
+                        issues.push(
+                            new Issue('warning', 'evals_json_assertion_field_type', `${aLoc} (kind=tool-choice) '${f}' must be an array of strings`),
+                        );
+                    }
+                }
+            } else if (kind === 'trajectory_budget') {
+                // trajectory_budget (eval-schema v2): required integer `n` >= 1.
+                if (typeof a.n !== 'number' || !Number.isInteger(a.n) || (a.n as number) < 1) {
+                    issues.push(
+                        new Issue('warning', 'evals_json_assertion_field_type', `${aLoc} (kind=trajectory_budget) 'n' must be an integer >= 1`),
+                    );
+                }
             } else {
-                const requiredField = { contains: 'value', file_exists: 'path', rubric: 'criterion' }[kind] as string;
+                const requiredField = { contains: 'value', not_contains: 'value', file_exists: 'path', rubric: 'criterion' }[kind] as string;
                 if (!(requiredField in a) || typeof a[requiredField] !== 'string') {
                     issues.push(
                         new Issue(

package/src/scripts/smoke_host_loadability.sh

@@ -0,0 +1,73 @@
+#!/usr/bin/env bash
+# smoke_host_loadability.sh — real-host loadability smoke
+# (road-to-ecosystem-harvest-skill-quality-gates Phase 4, Source G).
+#
+# The static check (check_host_loadability.ts) proves the generated trees
+# PARSE; this smoke proves the real Claude Code CLI actually ACCEPTS them:
+#
+#   1. `claude plugin validate .claude-plugin` — the host's own validator on
+#      the marketplace manifest + plugin dirs.
+#   2. Temp-home install: add this repo as a marketplace in a throwaway HOME,
+#      install the bootstrap-shim plugin, assert it shows up in
+#      `claude plugin list`. Nothing touches the developer's real ~/.claude.
+#   3. Metadata cross-consistency (marketplace ↔ plugin dirs ↔ docs):
+#      lint_marketplace + lint_marketplace_install_completeness +
+#      lint_supported_tools_matrix + check_host_loadability.
+#
+# Contract: OPTIONAL in CI (runners without the claude CLI skip with exit 0
+# and a notice), REQUIRED before releases — pass --require to make a missing
+# CLI a failure (wired into the release flow, see docs/contracts/release-pr-gating.md).
+set -euo pipefail
+
+REPO_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+cd "$REPO_ROOT"
+
+REQUIRE=0
+for arg in "$@"; do
+  case "$arg" in
+    --require) REQUIRE=1 ;;
+    *) echo "usage: smoke_host_loadability.sh [--require]" >&2; exit 2 ;;
+  esac
+done
+
+CLAUDE_BIN="${CLAUDE_CLI:-$(command -v claude || true)}"
+if [ -n "$CLAUDE_BIN" ] && [ ! -x "$CLAUDE_BIN" ]; then
+  CLAUDE_BIN=""
+fi
+if [ -z "$CLAUDE_BIN" ]; then
+  if [ "$REQUIRE" -eq 1 ]; then
+    echo "❌  claude CLI not found and --require set (release gate). Install Claude Code or set CLAUDE_CLI." >&2
+    exit 1
+  fi
+  echo "⚠️  claude CLI not found — real-host smoke skipped (static checks still run)."
+  ./scripts-run src/scripts/check_host_loadability --root .
+  ./scripts-run src/scripts/lint_supported_tools_matrix
+  exit 0
+fi
+
+MARKETPLACE_NAME="$(node -e "console.log(JSON.parse(require('node:fs').readFileSync('.claude-plugin/marketplace.json','utf8')).name)")"
+PLUGIN_NAME="$(node -e "console.log(JSON.parse(require('node:fs').readFileSync('.claude-plugin/marketplace.json','utf8')).plugins[0].name)")"
+
+echo "→ 1/3 host-CLI manifest validation (claude plugin validate)"
+# validate expects the directory that CONTAINS .claude-plugin/.
+"$CLAUDE_BIN" plugin validate "$REPO_ROOT"
+
+echo "→ 2/3 temp-home install + load assertion (${PLUGIN_NAME}@${MARKETPLACE_NAME})"
+TMP_HOME="$(mktemp -d)"
+cleanup() { rm -rf "$TMP_HOME"; }
+trap cleanup EXIT
+export ANTHROPIC_API_KEY="${ANTHROPIC_API_KEY:-}"
+HOME="$TMP_HOME" "$CLAUDE_BIN" plugin marketplace add "$REPO_ROOT"
+HOME="$TMP_HOME" "$CLAUDE_BIN" plugin install "${PLUGIN_NAME}@${MARKETPLACE_NAME}"
+if ! HOME="$TMP_HOME" "$CLAUDE_BIN" plugin list | grep -q "$PLUGIN_NAME"; then
+  echo "❌  plugin '${PLUGIN_NAME}' not listed after temp-home install — host did not load it" >&2
+  exit 1
+fi
+
+echo "→ 3/3 metadata cross-consistency (marketplace ↔ plugin dirs ↔ docs)"
+./scripts-run src/scripts/lint_marketplace
+./scripts-run src/scripts/lint_marketplace_install_completeness
+./scripts-run src/scripts/lint_supported_tools_matrix
+./scripts-run src/scripts/check_host_loadability --root .
+
+echo "✅  host-loadability smoke green (validate + temp-home install + cross-consistency)"