ai-engineering-loop 1.0.10 → 1.0.12

package/lib/orchestration.js

@@ -320,6 +320,7 @@ function validateFindingLedger(ledger) {
   const validSeverities = ['BLOCKER', 'HIGH', 'MEDIUM', 'LOW'];
   const validValidities = ['VALID', 'INVALID'];
   const validDispositions = ['STRONG', 'ACCEPTABLE', 'WEAK'];
+  const validAxes = ['spec', 'standards'];
 
   for (let i = 0; i < ledger.findings.length; i++) {
     const f = ledger.findings[i];
@@ -327,6 +328,10 @@ function validateFindingLedger(ledger) {
       return { valid: false, reason: `Finding at index ${i} missing required id, location, failureScenario, or evidence` };
     }
 
+    if (f.axis != null && !validAxes.includes(f.axis)) {
+      return { valid: false, reason: `Invalid axis at index ${i}: ${f.axis}. Must be spec or standards` };
+    }
+
     if (!validSeverities.includes(f.severity)) {
       return { valid: false, reason: `Invalid severity at index ${i}: ${f.severity}. Must be: ${validSeverities.join(', ')}` };
     }
@@ -348,7 +353,19 @@ function validateFindingLedger(ledger) {
 }
 
 /**
- * 8. Compute Judge Verdict based primarily on Validity + Severity
+ * Spec VALID BLOCKER/HIGH blocks. Missing axis is spec.
+ * Standards VALID BLOCKER/HIGH blocks only when hardConvention is true.
+ */
+function isBlockingFinding(finding) {
+  if (!finding || finding.validity !== 'VALID') return false;
+  if (finding.severity !== 'BLOCKER' && finding.severity !== 'HIGH') return false;
+  const axis = finding.axis || 'spec';
+  if (axis === 'standards' && finding.hardConvention !== true) return false;
+  return true;
+}
+
+/**
+ * 8. Compute Judge Verdict based primarily on Validity + Severity, then review axis
  */
 function computeJudgeVerdict({
   goalContract,
@@ -380,7 +397,7 @@ function computeJudgeVerdict({
       continue;
     }
 
-    if (f.severity === 'BLOCKER' || f.severity === 'HIGH') {
+    if (isBlockingFinding(f)) {
       blockingFindings.push(f);
     } else {
       acceptableFindings.push(f);
@@ -581,6 +598,7 @@ module.exports = {
   buildReviewContextBarrier,
   validateVerificationEvidence,
   validateFindingLedger,
+  isBlockingFinding,
   computeJudgeVerdict,
   formatExecutionReport,
   detectGrokRuntime,

package/lib/sync-hosts.js

@@ -0,0 +1,195 @@
+'use strict';
+
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+
+function packageRoot() {
+  return path.join(__dirname, '..');
+}
+
+function homeDir(env = process.env) {
+  if (env.AEL_HOME) return env.AEL_HOME;
+  return os.homedir();
+}
+
+function applyGrokSkillOverlay(content) {
+  const match = content.match(/^---\n([\s\S]*?)\n---\n/);
+  if (!match) return content;
+  const yaml = match[1];
+  if (/^user-invocable:\s*true\s*$/m.test(yaml)) return content;
+  const nextYaml = `${yaml.replace(/\s*$/, '')}\nuser-invocable: true`;
+  return `---\n${nextYaml}\n---\n${content.slice(match[0].length)}`;
+}
+
+function hostFileMap(home) {
+  const claude = path.join(home, '.claude');
+  const grok = path.join(home, '.grok');
+  const gemini = path.join(home, '.gemini');
+  const agents = path.join(home, '.agents');
+  return [
+    {
+      id: 'claude',
+      root: claude,
+      files: [
+        { src: '.claude/skills/ai-engineering-loop/SKILL.md', dest: path.join(claude, 'skills/ai-engineering-loop/SKILL.md'), mode: 'upsert' },
+        { src: '.claude/agents/devil-advocate.md', dest: path.join(claude, 'agents/devil-advocate.md'), mode: 'upsert' },
+        { src: '.claude/agents/judge.md', dest: path.join(claude, 'agents/judge.md'), mode: 'upsert' },
+        { src: '.claude/commands/ai-engineering-loop.md', dest: path.join(claude, 'commands/ai-engineering-loop.md'), mode: 'upsert' }
+      ]
+    },
+    {
+      id: 'grok',
+      root: grok,
+      files: [
+        { src: '.grok/skills/ai-engineering-loop/SKILL.md', dest: path.join(grok, 'skills/ai-engineering-loop/SKILL.md'), mode: 'upsert', grokSkillOverlay: true },
+        { src: '.grok/agents/devil-advocate.md', dest: path.join(grok, 'agents/devil-advocate.md'), mode: 'upsert' },
+        { src: '.grok/agents/judge.md', dest: path.join(grok, 'agents/judge.md'), mode: 'upsert' },
+        { src: '.grok/commands/ai-engineering-loop.md', dest: path.join(grok, 'commands/ai-engineering-loop.md'), mode: 'upsert' }
+      ]
+    },
+    {
+      id: 'gemini',
+      root: gemini,
+      files: [
+        { src: '.gemini/skills/ai-engineering-loop/SKILL.md', dest: path.join(gemini, 'config/skills/ai-engineering-loop/SKILL.md'), mode: 'upsert' }
+      ]
+    },
+    {
+      id: 'antigravity',
+      root: agents,
+      files: [
+        { src: '.agents/devil-advocate.md', dest: path.join(agents, 'devil-advocate.md'), mode: 'upsert' },
+        { src: '.agents/judge.md', dest: path.join(agents, 'judge.md'), mode: 'upsert' },
+        { src: '.agents/workflows/ai-engineering-loop.md', dest: path.join(agents, 'workflows/ai-engineering-loop.md'), mode: 'upsert' }
+      ]
+    },
+    {
+      id: 'dot',
+      root: null,
+      files: [
+        { src: 'adapters/dot/skills/dot-dev-skill-router/SKILL.md', dest: path.join(claude, 'skills/dot-dev-skill-router/SKILL.md'), mode: 'update-if-exists', hostRoot: claude },
+        { src: 'adapters/dot/skills/dot-dev-workflow/SKILL.md', dest: path.join(claude, 'skills/dot-dev-workflow/SKILL.md'), mode: 'update-if-exists', hostRoot: claude },
+        { src: 'adapters/dot/skills/dot-dev-skill-router/SKILL.md', dest: path.join(grok, 'skills/dot-dev-skill-router/SKILL.md'), mode: 'update-if-exists', hostRoot: grok, grokSkillOverlay: true },
+        { src: 'adapters/dot/skills/dot-dev-workflow/SKILL.md', dest: path.join(grok, 'skills/dot-dev-workflow/SKILL.md'), mode: 'update-if-exists', hostRoot: grok, grokSkillOverlay: true },
+        { src: 'adapters/dot/skills/dot-dev-skill-router/SKILL.md', dest: path.join(gemini, 'config/skills/dot-dev-skill-router/SKILL.md'), mode: 'update-if-exists', hostRoot: gemini },
+        { src: 'adapters/dot/skills/dot-dev-workflow/SKILL.md', dest: path.join(gemini, 'config/skills/dot-dev-workflow/SKILL.md'), mode: 'update-if-exists', hostRoot: gemini }
+      ]
+    }
+  ];
+}
+
+function destExists(dest) {
+  try {
+    fs.lstatSync(dest);
+    return true;
+  } catch (e) {
+    return false;
+  }
+}
+
+function isSymlink(dest) {
+  try {
+    return fs.lstatSync(dest).isSymbolicLink();
+  } catch (e) {
+    return false;
+  }
+}
+
+function planHostSync({ packageRoot: root = packageRoot(), home = homeDir() } = {}) {
+  const results = [];
+  for (const group of hostFileMap(home)) {
+    for (const file of group.files) {
+      const srcAbs = path.join(root, file.src);
+      const hostRoot = file.hostRoot || group.root;
+      const item = {
+        id: group.id,
+        src: file.src,
+        dest: file.dest,
+        mode: file.mode
+      };
+      if (hostRoot && !fs.existsSync(hostRoot)) {
+        results.push({ ...item, action: 'skip', reason: 'host-missing' });
+        continue;
+      }
+      if (!fs.existsSync(srcAbs)) {
+        results.push({ ...item, action: 'skip', reason: 'src-missing' });
+        continue;
+      }
+      if (isSymlink(file.dest)) {
+        results.push({ ...item, action: 'skip', reason: 'symlink' });
+        continue;
+      }
+      if (file.mode === 'update-if-exists' && !destExists(file.dest)) {
+        results.push({ ...item, action: 'skip', reason: 'not-installed' });
+        continue;
+      }
+      let content = fs.readFileSync(srcAbs, 'utf8');
+      if (file.grokSkillOverlay) content = applyGrokSkillOverlay(content);
+      if (destExists(file.dest) && fs.readFileSync(file.dest, 'utf8') === content) {
+        results.push({ ...item, action: 'current' });
+        continue;
+      }
+      results.push({ ...item, action: 'copy', content });
+    }
+  }
+  return results;
+}
+
+function applyHostSync({ packageRoot: root = packageRoot(), home = homeDir(), dryRun = false } = {}) {
+  const plan = planHostSync({ packageRoot: root, home });
+  const applied = [];
+  for (const item of plan) {
+    if (item.action !== 'copy') {
+      applied.push(item);
+      continue;
+    }
+    if (!dryRun) {
+      fs.mkdirSync(path.dirname(item.dest), { recursive: true });
+      fs.writeFileSync(item.dest, item.content);
+    }
+    applied.push({ ...item, content: undefined, dryRun });
+  }
+  return applied;
+}
+
+function summarizeHostSync(results) {
+  const summary = { copy: 0, current: 0, skip: 0 };
+  for (const item of results) {
+    if (item.action === 'copy') summary.copy += 1;
+    else if (item.action === 'current') summary.current += 1;
+    else summary.skip += 1;
+  }
+  return summary;
+}
+
+function formatHostSyncReport(results, { version, dryRun = false } = {}) {
+  const summary = summarizeHostSync(results);
+  const lines = [
+    `Host skills sync (v${version || 'unknown'})${dryRun ? ' [dry-run]' : ''}`,
+    `- copy: ${summary.copy}  current: ${summary.current}  skip: ${summary.skip}`
+  ];
+  for (const item of results) {
+    if (item.action === 'skip' && item.reason === 'host-missing') continue;
+    if (item.action === 'skip' && item.reason === 'not-installed') continue;
+    const rel = item.dest;
+    if (item.action === 'copy') lines.push(`  ${item.id.padEnd(12)} ${dryRun ? 'would-copy' : 'copied'}  ${rel}`);
+    else if (item.action === 'current') lines.push(`  ${item.id.padEnd(12)} current     ${rel}`);
+    else lines.push(`  ${item.id.padEnd(12)} skip(${item.reason}) ${rel}`);
+  }
+  if (summary.copy > 0 && !dryRun) {
+    lines.push('Skill text already loaded in this session stays stale until you start a new session.');
+  }
+  return lines.join('\n');
+}
+
+module.exports = {
+  packageRoot,
+  homeDir,
+  applyGrokSkillOverlay,
+  hostFileMap,
+  planHostSync,
+  applyHostSync,
+  summarizeHostSync,
+  formatHostSyncReport
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ai-engineering-loop",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "description": "A reusable, framework-agnostic AI Engineering Operating System for autonomous coding agents.",
   "main": "bin/ai-engineering-loop.js",
   "bin": {
@@ -21,6 +21,7 @@
     "scripts/",
     ".agents/",
     ".grok/",
+    ".gemini/skills/",
     ".claude/agents/",
     ".claude/commands/",
     ".claude/skills/",

package/policies/finding-policy.md

@@ -20,6 +20,10 @@ id: "<CATEGORY_PREFIX>-<3_DIGIT_NUMBER>" # e.g. COR-001, SEC-002, PERF-001
 title: "<Short, descriptive summary of the problem>"
 topic: "<correctness | error_handling | security | concurrency | performance | maintainability | testing_gaps>"
 
+# Review axis (do not merge Spec with Standards)
+axis: "<spec | standards>" # spec: Goal Contract / runtime defect | standards: conventions.md or smell baseline
+hardConvention: false # true only when conventions.md states a hard rule this hunk violates
+
 # Axis 1: Factual Validity
 validity: "<VALID | INVALID>" # VALID: Real technical flaw | INVALID: Reviewer hallucination or misunderstanding
 
@@ -66,5 +70,7 @@ Review findings are hypotheses, not absolute truths.
 - **`INVALID` (Dismissed)**: The reviewer made an assumption disproved by the codebase, referenced a non-existent API, or flagged intentional behavior.
 
 > [!IMPORTANT]
-> **Decision Rule**: The Judge Agent evaluates findings primarily on **Validity + Severity**.
+> **Decision Rule**: The Judge Agent evaluates findings primarily on **Validity + Severity**, then on **review axis**.
 > A reviewer's subjective disposition (`STRONG`, `ACCEPTABLE`, `WEAK`) **never overrides evidence**. An `INVALID` finding cannot block delivery, even if the reviewer labeled it `STRONG` or `BLOCKER`.
+> Spec (`axis: spec`) VALID BLOCKER/HIGH forces `ITERATE`. Standards (`axis: standards`) VALID BLOCKER/HIGH forces `ITERATE` only when `hardConvention: true`. Other Standards findings are tradeoffs. Missing `axis` is treated as `spec`.
+> Do not merge Spec and Standards into one ranking. A change can pass one axis and fail the other.

package/policies/review-budget.md

@@ -2,6 +2,13 @@
 
 Applies to Devil's Advocate and Judge on Claude Code, Grok CLI, and Antigravity. Parent always waits; children never run in the background.
 
+The **agent body** (instructions + JSON output) is identical on all three hosts. Source of truth:
+
+- `agents/shared/devil-advocate.body.md`
+- `agents/shared/judge.body.md`
+
+Host files (`.claude/agents/`, `.grok/agents/`, `.agents/`) may differ only in YAML frontmatter (tool names). Tests fail if a host body drifts.
+
 ## Shared spawn rules
 
 - Write `git diff` to `.ai-engineering-loop/tasks/current.diff` before review.
@@ -15,6 +22,7 @@ Applies to Devil's Advocate and Judge on Claude Code, Grok CLI, and Antigravity.
 - At most **8** tool calls, then emit the Finding Ledger.
 - Read the diff file first. Do not run `git diff` if that path was given.
 - Open at most **8** files that appear in the diff. Prefer quoting a hunk over opening the whole file.
+- Report Spec and Standards as separate findings. Do not spawn children to split axes. Do not merge the two axes.
 
 ## Judge
 

package/policies/tdd-policy.md

@@ -0,0 +1,32 @@
+# TDD Policy (Maker, Stages 4–5)
+
+Maker implements with a red → green loop at **pre-agreed seams**. Refactoring is not part of this loop; it belongs to a later Goal Contract or to review.
+
+Canonical Maker rules: `agents/maker.md`. Verification evidence: `core/verification-loop.md`.
+
+## Seams
+
+A seam is the public interface where you observe behavior without reaching inside. Seams are named in the Goal Contract during Stage 1. Prefer existing seams. The ideal number of new seams is zero; the next best is one.
+
+No test is written at an unconfirmed seam. If the contract omitted seams and grill was skipped, name them in the plan (Stage 3) and freeze them in the contract before the first red test.
+
+## What a good test is
+
+The test reads like a specification of behavior at the seam. Names use `.ai-engineering-loop/glossary.md`. The test survives an internal rewrite. Expected values come from the Goal Contract or a known-good literal, not from re-running the implementation.
+
+## Loop
+
+1. **Red.** Write one failing test for one AC slice. Confirm it fails for the right reason.
+2. **Green.** Write the smallest production change that passes that test.
+3. Repeat one slice at a time (vertical). Do not write the whole suite first.
+4. After slices covering AC-1..N, run the full verification commands in `.ai-engineering-loop/verification.md` and keep the Evidence Contract.
+
+## Forbidden tests
+
+- **Implementation-coupled:** mocks internal collaborators, tests private methods, or asserts through a side channel (raw DB) instead of the seam.
+- **Tautological:** expected value is computed the same way as the code (`expect(add(a,b)).toBe(a+b)`).
+- **Horizontal slicing:** all tests first, then all implementation.
+
+## Evidence
+
+Stage 5 still requires command, exit code 0, stdout, test counts, and assertionEvidence mapped to AC ids. "We did TDD" is not evidence. A red-then-green story without logs is invalid.

package/scripts/init.sh

@@ -81,5 +81,26 @@ cat <<EOF > .ai-engineering-loop/adapter.md
 - **default_target_branch**: "main"
 EOF
 
+cat <<EOF > .ai-engineering-loop/glossary.md
+# Ubiquitous Language
+
+One term per concept. Use these words in Goal Contracts, tests, and code names.
+
+## Terms
+
+| Term | Meaning | Do not say |
+|---|---|---|
+| Goal Contract | Frozen Stage 1 acceptance document | "the prompt" |
+| Seam | Public interface under test | "the internals" |
+EOF
+
+mkdir -p .ai-engineering-loop/adrs
+cat <<EOF > .ai-engineering-loop/adrs/README.md
+# Architecture Decision Records
+
+Write one ADR when Stage 1 grill settles a load-bearing choice.
+File name: NNN-short-kebab-title.md
+EOF
+
 echo -e "\033[1;32m✓ .ai-engineering-loop/ successfully initialized!\033[0m"
 echo -e "You can now run the AI Engineering Loop on this repository."

package/templates/repo-config/adr-readme.md

@@ -0,0 +1,33 @@
+# Architecture Decision Records
+
+Hard decisions that would otherwise live only in chat. Write one ADR when Stage 1 grill settles a choice that future agents must not re-litigate.
+
+## When to write
+
+- Two viable designs were on the table and one was chosen
+- A boundary, schema, or public seam is now load-bearing
+- The Goal Contract's Technical Constraints need a durable why
+
+Do not write an ADR for a typo fix, a local rename, or a test-only change.
+
+## File name
+
+`NNN-short-kebab-title.md` in this directory. Increment `NNN`.
+
+## Template
+
+```markdown
+# ADR NNN: <title>
+
+## Status
+Accepted | Superseded by ADR NNN
+
+## Context
+What forced a choice.
+
+## Decision
+What we chose, in glossary terms.
+
+## Consequences
+What becomes easier, harder, or forbidden.
+```

package/templates/repo-config/glossary.md

@@ -0,0 +1,18 @@
+# Ubiquitous Language
+
+One term per concept. Agents and humans use these words in Goal Contracts, tests, code names, and review. Prefer a short term over a 20-word paraphrase.
+
+Update this file during Stage 1 grill when a term is coined or corrected. Do not invent parallel synonyms.
+
+## Terms
+
+| Term | Meaning | Do not say |
+|---|---|---|
+| Goal Contract | Frozen Stage 1 acceptance document | "the prompt", "the ticket vibe" |
+| Seam | Public interface under test | "the internals", "the private helper" |
+
+## How to add a term
+
+1. Can this idea be named in 1–4 words?
+2. Does an existing term already cover it? Reuse it.
+3. Add one row. Use the term in the next Goal Contract.

package/tests/living-context.test.js

@@ -0,0 +1,46 @@
+const test = require('node:test');
+const assert = require('node:assert');
+const fs = require('fs');
+const os = require('os');
+const path = require('path');
+const { execFileSync } = require('child_process');
+
+const CLI = path.join(__dirname, '..', 'bin', 'ai-engineering-loop.js');
+
+function tmpRepo() {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'ael-'));
+  fs.writeFileSync(
+    path.join(dir, 'package.json'),
+    JSON.stringify({ name: 'fixture', scripts: { test: 'node -e ""' } }, null, 2)
+  );
+  return dir;
+}
+
+test('init writes glossary.md and adrs/README.md', () => {
+  const dir = tmpRepo();
+  execFileSync('node', [CLI, 'init'], { cwd: dir, encoding: 'utf8' });
+  const glossary = path.join(dir, '.ai-engineering-loop', 'glossary.md');
+  const adr = path.join(dir, '.ai-engineering-loop', 'adrs', 'README.md');
+  assert.ok(fs.existsSync(glossary));
+  assert.ok(fs.existsSync(adr));
+  assert.match(fs.readFileSync(glossary, 'utf8'), /Ubiquitous Language/);
+  assert.match(fs.readFileSync(adr, 'utf8'), /Architecture Decision Records/);
+});
+
+test('repair fills missing glossary without overwriting a filled glossary or architecture', () => {
+  const dir = tmpRepo();
+  execFileSync('node', [CLI, 'init'], { cwd: dir, encoding: 'utf8' });
+  const glossary = path.join(dir, '.ai-engineering-loop', 'glossary.md');
+  const architecture = path.join(dir, '.ai-engineering-loop', 'architecture.md');
+  fs.writeFileSync(glossary, '# Custom glossary\n- Foo: bar\n');
+  const archBefore = fs.readFileSync(architecture, 'utf8');
+  fs.unlinkSync(glossary);
+  execFileSync('node', [CLI, 'init'], { cwd: dir, encoding: 'utf8' });
+  assert.ok(fs.existsSync(glossary));
+  assert.strictEqual(fs.readFileSync(architecture, 'utf8'), archBefore);
+  fs.writeFileSync(glossary, '# Custom glossary\n- Foo: bar\n');
+  fs.unlinkSync(architecture);
+  execFileSync('node', [CLI, 'init'], { cwd: dir, encoding: 'utf8' });
+  assert.match(fs.readFileSync(glossary, 'utf8'), /Foo: bar/);
+  assert.ok(fs.existsSync(architecture));
+});

package/tests/orchestration.test.js

@@ -286,3 +286,83 @@ test('D, F, G. Judge Decision Matrix: VALID BLOCKER forces ITERATE; INVALID does
   assert.strictEqual(verdictTradeoff.verdict, 'PASS');
   assert.strictEqual(verdictTradeoff.acceptableTradeoffs.length, 1);
 });
+
+test('Standards axis BLOCKER does not iterate unless hardConvention is true', () => {
+  const goalContract = { objective: 'Test' };
+  const verificationEvidence = {
+    command: 'npm test',
+    executionIdentity: 'exec-1',
+    startTime: '2026-08-25T10:00:00Z',
+    endTime: '2026-08-25T10:00:02Z',
+    exitCode: 0,
+    stdout: '10 passed',
+    timeoutStatus: 'COMPLETED',
+    testCounts: { passed: 10, failed: 0 }
+  };
+
+  const smellLedger = {
+    findings: [
+      {
+        id: 'DA-S1',
+        axis: 'standards',
+        hardConvention: false,
+        severity: 'HIGH',
+        validity: 'VALID',
+        disposition: 'STRONG',
+        location: 'src/pay.ts#L4',
+        failureScenario: 'Duplicated Code across two hunks',
+        evidence: 'Same lock shape in two functions'
+      }
+    ]
+  };
+
+  const smellVerdict = computeJudgeVerdict({
+    goalContract,
+    verificationEvidence,
+    findingLedger: smellLedger,
+    activeIteration: 1
+  });
+  assert.strictEqual(smellVerdict.verdict, 'PASS');
+  assert.strictEqual(smellVerdict.acceptableTradeoffs.length, 1);
+
+  const hardLedger = {
+    findings: [
+      {
+        id: 'DA-S2',
+        axis: 'standards',
+        hardConvention: true,
+        severity: 'HIGH',
+        validity: 'VALID',
+        disposition: 'STRONG',
+        location: 'src/pay.ts#L4',
+        failureScenario: 'conventions.md forbids any',
+        evidence: 'any used in public seam',
+        concreteAlternativeDiff: '- x: any\n+ x: unknown'
+      }
+    ]
+  };
+
+  const hardVerdict = computeJudgeVerdict({
+    goalContract,
+    verificationEvidence,
+    findingLedger: hardLedger,
+    activeIteration: 1
+  });
+  assert.strictEqual(hardVerdict.verdict, 'ITERATE');
+  assert.strictEqual(hardVerdict.blockingFindings.length, 1);
+});
+
+test('Finding ledger rejects unknown axis; missing axis remains valid', () => {
+  const base = {
+    id: 'DA-1',
+    severity: 'LOW',
+    validity: 'VALID',
+    disposition: 'ACCEPTABLE',
+    location: 'src/a.ts#L1',
+    failureScenario: 'n',
+    evidence: 'e'
+  };
+  assert.strictEqual(validateFindingLedger({ findings: [base] }).valid, true);
+  assert.strictEqual(validateFindingLedger({ findings: [{ ...base, axis: 'spec' }] }).valid, true);
+  assert.strictEqual(validateFindingLedger({ findings: [{ ...base, axis: 'style' }] }).valid, false);
+});